tree 351054cdbf869574ea723ed9ba775b267f253cd7
parent d69cfa3a843407aea541b240a1f0c65a9a802430
author Googler <noreply@google.com> 1614341039 -0500
committer swiftshader-scoped@luci-project-accounts.iam.gserviceaccount.com <swiftshader-scoped@luci-project-accounts.iam.gserviceaccount.com> 1614363901 +0000

Support LLVM 11+ atomic instruction alignment change

Atomic instructions now take an alignment parameter.

llvm::MaybeAlign() means undefined alignment, which makes the compiler
emit atomic operations that can handle unaligned data. This is probably
overly conservative since our use cases typically ensure alignment. But
that's an optimization we can prudently make later if/when proven
useful.

Bug: b/165000222
Change-Id: I2d0f0f0b5ae8ca811e97c2f5e2f34cc06ca7ee09
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/53308
Presubmit-Ready: Nicolas Capens <nicolascapens@google.com>
Tested-by: Nicolas Capens <nicolascapens@google.com>
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
Kokoro-Result: kokoro <noreply+kokoro@google.com>
Commit-Queue: Nicolas Capens <nicolascapens@google.com>
