cmd/compile: R12 can be clobbered for write barrier call on PPC64 #40851
Comments
|
Change https://golang.org/cl/248917 mentions this issue: |
|
@ianlancetaylor pointed out that for future-proof, the external linker could clobber any caller-saved register that cannot be used for function arguments, that also includes R11. We could consider marking R11 as clobbered as well. |
|
@gopherbot please consider backporting this to Go 1.15. Thanks. |
|
Backport issue(s) opened: #40868 (for 1.15). Remember to create the cherry-pick CL(s) as soon as the patch is submitted to master, according to https://golang.org/wiki/MinorReleases. |
|
Change https://golang.org/cl/249019 mentions this issue: |
|
@cherrymui , does this also need a 1.14 backport? I'm pretty sure it does. |
|
Yeah, I think it also has this problem in Go 1.14. |
|
@gopherbot please consider backporting this to Go 1.14. Thanks. |
|
GopherBot is lazy (#25574), so I'm afraid you'll have to open the 1.14 backport issue by hand. |
|
Change https://golang.org/cl/249697 mentions this issue: |
dmitshur
added
the
NeedsFix
…write barrier call on PPC64 When external linking, for large binaries, the external linker may insert a trampoline for the write barrier call, which looks 0000000005a98cc8 <__long_branch_runtime.gcWriteBarrier>: 5a98cc8: 86 01 82 3d addis r12,r2,390 5a98ccc: d8 bd 8c e9 ld r12,-16936(r12) 5a98cd0: a6 03 89 7d mtctr r12 5a98cd4: 20 04 80 4e bctr It clobbers R12 (and CTR, which is never live across a call). As at compile time we don't know whether the binary is big and what link mode will be used, I think we need to mark R12 as clobbered for write barrier call. For extra safety (future-proof) we mark caller-saved register that cannot be used for function arguments, which includes R11, as potentially clobbered as well. Updates #40851. Fixes #40868. Change-Id: Iedd901c5072f1127cc59b0a48cfeb4aaec81b519 Reviewed-on: https://go-review.googlesource.com/c/go/+/248917 Run-TryBot: Cherry Zhang <cherryyz@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com> (cherry picked from commit b58d297) Reviewed-on: https://go-review.googlesource.com/c/go/+/249019
…write barrier call on PPC64 When external linking, for large binaries, the external linker may insert a trampoline for the write barrier call, which looks 0000000005a98cc8 <__long_branch_runtime.gcWriteBarrier>: 5a98cc8: 86 01 82 3d addis r12,r2,390 5a98ccc: d8 bd 8c e9 ld r12,-16936(r12) 5a98cd0: a6 03 89 7d mtctr r12 5a98cd4: 20 04 80 4e bctr It clobbers R12 (and CTR, which is never live across a call). As at compile time we don't know whether the binary is big and what link mode will be used, I think we need to mark R12 as clobbered for write barrier call. For extra safety (future-proof) we mark caller-saved register that cannot be used for function arguments, which includes R11, as potentially clobbered as well. Updates #40851. Fixes #40938. Change-Id: Iedd901c5072f1127cc59b0a48cfeb4aaec81b519 Reviewed-on: https://go-review.googlesource.com/c/go/+/248917 Run-TryBot: Cherry Zhang <cherryyz@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com> (cherry picked from commit b58d297) Reviewed-on: https://go-review.googlesource.com/c/go/+/249697
…write barrier call on PPC64 When external linking, for large binaries, the external linker may insert a trampoline for the write barrier call, which looks 0000000005a98cc8 <__long_branch_runtime.gcWriteBarrier>: 5a98cc8: 86 01 82 3d addis r12,r2,390 5a98ccc: d8 bd 8c e9 ld r12,-16936(r12) 5a98cd0: a6 03 89 7d mtctr r12 5a98cd4: 20 04 80 4e bctr It clobbers R12 (and CTR, which is never live across a call). As at compile time we don't know whether the binary is big and what link mode will be used, I think we need to mark R12 as clobbered for write barrier call. For extra safety (future-proof) we mark caller-saved register that cannot be used for function arguments, which includes R11, as potentially clobbered as well. Updates golang#40851. Fixes golang#40868. Change-Id: Iedd901c5072f1127cc59b0a48cfeb4aaec81b519 Reviewed-on: https://go-review.googlesource.com/c/go/+/248917 Run-TryBot: Cherry Zhang <cherryyz@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com> (cherry picked from commit b58d297) Reviewed-on: https://go-review.googlesource.com/c/go/+/249019
Most Go function calls potentially clobber all registers, except a small set of special ones, including the write barrier call. Currently, on PPC64, the write barrier call is marked as preserving R0, R3-R15 (except R13), and R20, R11. In external linking mode, for large binaries, the external linker may insert a trampoline for the write barrier call, which looks like
It clobbers R12 (and CTR, which is never live across a call).
As at compile time we don't know whether the binary is big and what link mode will be used, I think we need to mark R12 as clobbered for write barrier call. I'll send a CL.
(Internal linking mode is okay, as the trampoline emitted by Go linker uses R31, the dedicated temp register, instead of R12.)
It has been like that several releases ago. I think we may want to back port, as there could cause runtime crash or data corruption without workaround.
The text was updated successfully, but these errors were encountered: