tree a84cf8f49a99001481ddd8876aa378db12f133fa
parent 6aae7dba00c85d44706622517746da0e25cd61b9
author Peter Kasting <pkasting@chromium.org> 1676309661 -0800
committer swiftshader-scoped@luci-project-accounts.iam.gserviceaccount.com <swiftshader-scoped@luci-project-accounts.iam.gserviceaccount.com> 1676315563 +0000

Compile in whatever C++ version is default.

There's no need to force C++17 (to gain C++17 features) since Chromium
has long built in C++17 mode, and in fact this hinders moving to C++20.
Use the version of C++ that the surrounding environment defaults to.

Bug: chromium:1284275
Change-Id: Ia4aade7891e42fe39d55e8049fdc84a8b2e6e51e
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/70769
Commit-Queue: Peter Kasting <pkasting@google.com>
Presubmit-Ready: Shahbaz Youssefi <syoussefi@google.com>
Tested-by: Peter Kasting <pkasting@google.com>
Kokoro-Result: kokoro <noreply+kokoro@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@google.com>
