[test] Make tests pass regardless of gnu++14/gnu++17 default

[MaskRay]

Summary

GCC from 11 onwards defaults to -std=gnu++17 for C++ source files. We want to do the same
(https://discourse.llvm.org/t/c-objc-switch-to-gnu-17-as-the-default-dialect/64360).
Add __cplusplus < 201703L, adjust -verify, or add -std=c++14 so that tests
will pass regardless of gnu++14/gnu++17 default.

We have a desire to mark a test compatible with multiple language standards.
There are ongoing discussions how to add markers in the long term:

• https://discourse.llvm.org/t/iterating-lit-run-lines/62596
• https://discourse.llvm.org/t/lit-run-a-run-line-multiple-times-with-different-replacements/64932

As a workaround in the short term, add lit substitutions %std_cxx98-,
%std_cxx11-14, etc. They can be used for tests which work across multiple
language standards. If a range has n standards, run lit multiple times, with
LIT_CLANG_STD_GROUP=0, LIT_CLANG_STD_GROUP=1, etc to cover all n standards.

[junaire]

I wonder what's the difference between this patch and https://reviews.llvm.org/D124434 ? Also add some reviewers that get involved in the previous discussion.

[aaron.ballman]

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

1–2

I'm not really keen on this sort of change because it loses test coverage for other language standard versions. We usually try to write our tests to be standard version agnostic and only specify a specific language mode only when absolutely necessary, which doesn't seem to be the case for a lot of the tests in this patch (like this one).

clang/test/CXX/basic/basic.stc/basic.stc.dynamic/p2.cpp

1

This is another example where we lose all testing in the future when we go to change the default language standard version. It's fine to have a C++14-specific test, but we should still have a test which has no mode specified.

[MaskRay]

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

1–2

I think we can identify such issues (tests which want to test the latest mature standard) and fix them post-transition. This way the transition patch feels more isolated and can more easily be reverted.

Not sure whether @junaire wants to work on this...

[aaron.ballman]

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

1–2

I think we can identify such issues (tests which want to test the latest mature standard) and fix them post-transition. This way the transition patch feels more isolated and can more easily be reverted.

That feels backwards to me, but maybe I'm misunderstanding. If there are tests that are specifically testing C++14 behavior (that did not carry forward into C++17 or later) but don't have a language standard specified on the RUN line, I think we should fix those *before* transitioning the default language standard version because those are NFC fixes that improve the test clarity even if we never make the transition. The transition patch should remain isolated and easily revertible with that approach, but there's less risk that nobody goes back and fixes the tests post-transition.

[junaire]

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

1–2

Not sure whether @junaire wants to work on this...

I don't think I have enough knowledge and experience to do this work, So I would like to abandon my previous patch to hope you can pick it up!

[MaskRay]

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

1–2

I'll fix some tests.

[MaskRay]

fix some tests in a better way

[aaron.ballman]

I didn't do a full review because I spotted enough concerns that we might want to talk about the approach more first. I think the goal should be to avoid adding a -std= to any RUN line unless the test really requires it. I spotted a lot of instances where we went from testing the current language standard mode to losing testing for all language modes later than 14 or 17, which will give us problems when we go to update to C++20 or beyond. I think we want to use more #if __cplusplus or disable diagnostics when possible.

I made another lamentation about the lack of lit facilities that I think would solve these problems for us, but that's a big ask and is not something I insist upon for this. But if you felt like it was a good approach and wanted to work on it, I certainly wouldn't be sad about it. :-D

clang/lib/Basic/LangStandards.cpp

81 ↗

(On Diff #451377)

Unintended change used to find the tests that needed updating?

clang/test/AST/ast-dump-undeduced-expr.cpp

1

What from this test requires C++14?

clang/test/AST/sourceranges.cpp

0–2

I assume this change is because we're testing c++17 on the next RUN line and you want to be sure we still get the old test coverage?

The trouble is, when we bump from C++17 to C++20, we'll lose the test coverage for the latest standard.

(Not your problem per se, but I continue to think we have a lit deficiency where we need some facilities to say "run this test in C++N and later", "run this test in C89 through CN", or "run this test in all C++ language modes", etc.)

clang/test/Analysis/blocks.m

2

What from this test is invalid in C++17?

clang/test/CXX/except/except.spec/p2-dynamic-types.cpp

1

Why not pass -Wno-dynamic-exception-spec instead of limiting the test (we support dynamic exception specifications in newer language modes and it would be good to not lose that test coverage there).

clang/test/CXX/except/except.spec/p9-dynamic.cpp

0–1

Same question here as above

[MaskRay]

Add lit substitutions

[MaskRay]

It will take some time to fix all tests properly. Let's have a guideline how to fix them properly. I tried fixing some using several patterns in the last revision. I didn't fix all, because it would likely lead to an unsatisfactory result and I would spend more time :)

A construct which causes an error with C++17 onwards

I keep the existing RUN: lines and use something like

#if __cplusplus < 201703L
void* operator new[](std::size_t) throw(std::bad_alloc); 
#endif

it the construct appears tested elsewhere or

register int ro; // expected-error {{illegal storage class on file-scoped variable}}
#if __cplusplus >= 201703L
// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
#elif __cplusplus >= 201103L
// expected-warning@-4 {{'register' storage class specifier is deprecated}}
#endif

if the test file appears the proper place to test the construct.

Pre-C++17 and C++17 have different results

I use something like

// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 -std=c++14 -fdata-sections -fcolor-diagnostics
// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++17 -fdata-sections -fcolor-diagnostics

...
  TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}}
                                       // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
                                       // precxx17-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}

Since every RUN line uses -std=.
Pros: using -verify avoids #if directives which make the result look better.
Cons: when we upgrade to C++20, 23, ..., the tests will become less relevant.

Discussion

Do we want to prefer #if in all cases? They work well with -verify tests but not so well with FileCheck since FileCheck does not ignore preprocessor skipped ranges.
Do all CodeGenCXX tests have to be fixed?

clang/test/AST/ast-dump-undeduced-expr.cpp

1

The C++17 diagnostics uses static inline constexpr while pre-C++17 uses static constexpr. Used a regex instead.

clang/test/AST/sourceranges.cpp

0–2

FileCheck does not ignore preprocessor skipped ranges, so it is very difficult to work with both C++14/C++17 defaults, if our intention is to not touch such tests in the default changing patch.

I think the best strategy is to do another pass to clean up the tests after the transition, not trying to address everything in this patch.

clang/test/Analysis/blocks.m

2

Added __attribute__((__nothrow__)) in C++17 mode.

clang/test/CXX/except/except.spec/p2-dynamic-types.cpp

1

TIL -Wno-dynamic-exception-spec. Adopted.

clang/test/CXX/except/except.spec/p9-dynamic.cpp

0–1

The check prefixes assume that this is for C++14.

[dblaikie]

I use something like

// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 -std=c++14 -fdata-sections -fcolor-diagnostics
// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++17 -fdata-sections -fcolor-diagnostics

...
  TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}}
                                       // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
                                       // precxx17-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}

Since every RUN line uses -std=.
Pros: using -verify avoids #if directives which make the result look better.
Cons: when we upgrade to C++20, 23, ..., the tests will become less relevant.

Yeah, that's the main/a major concern as @aaron.ballman has mentioned.

I think in this case a regex over either would be acceptable, since the test probably wasn't intending to test the particular wording for a particular version (presumably if this is the place where this separate wording is uniquely used (rather than some generic diagnostic infrastructure change) then it's got a C++17 test already)

Discussion

Do we want to prefer #if in all cases? They work well with -verify tests but not so well with FileCheck since FileCheck does not ignore preprocessor skipped ranges.

I think where #if works well, it seems good to prefer it, yeah.

Do all CodeGenCXX tests have to be fixed?

I think so.

clang/test/AST/sourceranges.cpp

0–2

I think the best strategy is to do another pass to clean up the tests after the transition, not trying to address everything in this patch.

Not everything needs to be addressed in this patch - these cleanups can be in several preliminary patches that are isolated and not dependent on the switch to C++17.

It looks like in this case there's one CHECK-1Z that's out of place (line 111, test seems to pass OK even if that's a plain CHECK so I guess it probably should be) - and the rest are all at the end, which could be moved to a separate file and done with a hardcoded C++17 target. (but yeah, after the default switch we might end up wanting to remove the hardcoded 17 (allowing the test to become "17 and above"), move more test coverage over to here and leave whatever's 14 specific in the old test)

(maybe as a separate pass, though, to your point - we might be able to go through and remove -std=c++17 from tests once that's the default, so the tests are forwards compatible to the next language version, most likely - but, again, a broader LIT feature that @aaron.ballman is referring to, where tests could specify which configurations (beyond language versions, this could also help cover things like... oh, right here: https://reviews.llvm.org/D125946, tests could be assumed to be correct for clang-repl too, and some mode where clang-repl's used instead of clang for broad-scale testing of clang-repl)

clang/test/CXX/except/except.spec/p9-dynamic.cpp

0–1

so in this case the 17 test could become language-agnostic after the version default change?

[aaron.ballman]

In D131464#3713705, @MaskRay wrote:

It will take some time to fix all tests properly. Let's have a guideline how to fix them properly. I tried fixing some using several patterns in the last revision. I didn't fix all, because it would likely lead to an unsatisfactory result and I would spend more time :)

A construct which causes an error with C++17 onwards

I keep the existing RUN: lines and use something like

#if __cplusplus < 201703L
void* operator new[](std::size_t) throw(std::bad_alloc); 
#endif

it the construct appears tested elsewhere or

register int ro; // expected-error {{illegal storage class on file-scoped variable}}
#if __cplusplus >= 201703L
// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
#elif __cplusplus >= 201103L
// expected-warning@-4 {{'register' storage class specifier is deprecated}}
#endif

if the test file appears the proper place to test the construct.

This makes sense to me for sema tests. For tests which cannot have errors in them, like codegen tests or analysis tests, I would say this is a case where we would exhaustively test the old language standards up to C++17 and not beyond (perhaps with a boilerplate comment about why no newer versions need to be tested).

Pre-C++17 and C++17 have different results

I use something like

// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 -std=c++14 -fdata-sections -fcolor-diagnostics
// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++17 -fdata-sections -fcolor-diagnostics

...
  TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}}
                                       // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
                                       // precxx17-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}

Since every RUN line uses -std=.
Pros: using -verify avoids #if directives which make the result look better.
Cons: when we upgrade to C++20, 23, ..., the tests will become less relevant.

Yeah, we want to avoid making the tests less relevant in the future when possible. The suggestion from @dblaikie to use a regex in this case makes a lot of sense to me in the situation where what's being tested is not specifically the divergence in diagnostic behavior. e.g., if the test is "do we give a sensible warning here?" then use a regex for this situation, but if the test is "do we give the correct form of the warning here?" then use -verify= and try to leave a RUN line without a specific language standard on it if possible.

Discussion

Do we want to prefer #if in all cases? They work well with -verify tests but not so well with FileCheck since FileCheck does not ignore preprocessor skipped ranges.

I wouldn't say "in all cases", but certainly in cases where it improves the readability of the test or ensures we don't lose test coverage. Cases with FileCheck are a problem, but hopefully aren't too prevalent in the Parser and Sema tests.

Do all CodeGenCXX tests have to be fixed?

Yes, but in that case I expect (at least for errors), it's more a matter of adding RUN lines for all the relevant modes we need to test (since codegen tests really should not be caring about warning diagnostic wording, though some tests still do).

clang/test/AST/sourceranges.cpp

0–2

Not everything needs to be addressed in this patch - these cleanups can be in several preliminary patches that are isolated and not dependent on the switch to C++17.

+1 -- I am imagining the way we want to go forward is to have several patches handling these cleanups. One can handle cases where we need to add a regex or a verify prefix, another which splits files into two as needed, another can introduce new lit features, another can start to use those features, and so on.

This way, the default changing patch can hopefully be relatively small and narrow in scope. Once it's landed, we probably will want to do even more cleanup like removing -std=c++17 RUN lines when possible, etc.

Ultimately, I think the lit feature improvements will require us to go through a lot/most/all-ish of the tests to fix up their RUN lines. When we made the switch to C++14, I don't think we went through and cleaned up tests that already specified -std=c++1y or -std=c++14, so I would not be surprised to see a bunch of tests that lost future version coverage from that switch as well. Whether we want to bite the bullet and do that work up front instead of looking at/touching a lot of tests twice is worth thinking about.

llvm/utils/lit/lit/llvm/config.py

574

If we like this approach, we should probably add add_stdc as well (not as part of this patch, we can do all of C++ first, then come back and hit up C after we've finished).

577

Maybe we can use clang_std_values[-1] so we don't have to hardcode this?

583

One thing we should consider is whether we want to run in *all* the specified language modes instead of just the newest mode. This will make running tests slower because we'll run significantly more of them, and it might get awkward if a lot of tests change behavior in the different language modes, so I don't suggest it as part of this patch.

[MaskRay]

Sorry, my previous main comment had been written before I introduced LIT_CLANG_STD_GROUP in llvm/utils/lit/lit/llvm/config.py. The multiple %clang_cc1 approach actually looks like the following.
Note the use of %stdcxx_17- to make the test future-proof.
(It is non-trivial to run one RUN line multiples times with different LIT_CLANG_STD_GROUP. For now I just test locally with different LIT_CLANG_STD_GROUP.)

// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 %stdcxx_11-14 -fdata-sections -fcolor-diagnostics
// RUN: %clang_cc1 %s -fsyntax-only -verify %stdcxx_17- -fdata-sections -fcolor-diagnostics

...
  TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}} \
                                       // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}} \
                                       // precxx17-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}

If this is changed to use #if __cplusplus >= 201703L, there will be multiple lines with relative line numbers (e.g. @-2 @-4)

register int ro; // expected-error {{illegal storage class on file-scoped variable}}
#if __cplusplus >= 201703L
// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
#elif __cplusplus >= 201103L
// expected-warning@-4 {{'register' storage class specifier is deprecated}}
#endif

Personally I prefer multiple %clang_cc1 over #if. The first few lines give users a first impression. The dispatch makes it clear the test has different behaviors with the %stdcxx_* described dialects.

llvm/utils/lit/lit/llvm/config.py

583

This is difficult in lit. Will answer in my main comment.

[aaron.ballman]

In D131464#3716905, @MaskRay wrote:

Sorry, my previous main comment had been written before I introduced LIT_CLANG_STD_GROUP in llvm/utils/lit/lit/llvm/config.py. The multiple %clang_cc1 approach actually looks like the following.
Note the use of %stdcxx_17- to make the test future-proof.
(It is non-trivial to run one RUN line multiples times with different LIT_CLANG_STD_GROUP. For now I just test locally with different LIT_CLANG_STD_GROUP.)

// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 %stdcxx_11-14 -fdata-sections -fcolor-diagnostics
// RUN: %clang_cc1 %s -fsyntax-only -verify %stdcxx_17- -fdata-sections -fcolor-diagnostics

...
  TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}} \
                                       // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}} \
                                       // precxx17-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}

Personally, I like this style. I tend to be a heavy user of -verify prefixes though, so I might be biased.

If this is changed to use #if __cplusplus >= 201703L, there will be multiple lines with relative line numbers (e.g. @-2 @-4)

register int ro; // expected-error {{illegal storage class on file-scoped variable}}
#if __cplusplus >= 201703L
// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
#elif __cplusplus >= 201103L
// expected-warning@-4 {{'register' storage class specifier is deprecated}}
#endif

FWIW, you don't have to use relative markers, but that uses an even less common idiom of bookmarks. e.g.,

register int ro; // expected-error {{illegal storage class on file-scoped variable}} \
                    #bookmark
#if __cplusplus >= 201703L
// expected-error@#bookmark {{ISO C++17 does not allow 'register' storage class specifier}}
#elif __cplusplus >= 201103L
// expected-warning@#bookmark {{'register' storage class specifier is deprecated}}
#endif

Personally I prefer multiple %clang_cc1 over #if. The first few lines give users a first impression. The dispatch makes it clear the test has different behaviors with the %stdcxx_* described dialects.

I tend to have the same opinion.

[MaskRay]

fix tests

[aaron.ballman]

I like the direction this is going; I ran into some questions on the tests about whether we should use a range or not and other small things, but I think this is getting close.

clang/test/CXX/temp/temp.res/temp.local/p3.cpp

2

Should this be C++17+?

clang/test/CodeGen/typedef_alignment_mismatch_warning.cpp

2

Same question here about C++17+?

clang/test/CodeGenCXX/exception-spec-decay.cpp

1

Should we drop the %stdcxx_98- entirely from tests and not have any -std flag (e.g., no such flags tells lit to run the test in all language modes, eventually)?

clang/test/CodeGenCXX/override-bit-field-layout.cpp

2

17+?

clang/test/CodeGenCXX/override-layout.cpp

1–14

Pre 14? Post 17?

clang/test/Layout/ms-x86-vtordisp.cpp

1–3

Is this test specific to C++14?

clang/test/Parser/cxx-casting.cpp

1–3

LG given that lit doesn't run multiple tests yet, so switching to a range would lose coverage.

clang/test/SemaCXX/libstdcxx_is_pod_hack.cpp

1

Is this one only for C++14 or should there be a range used instead?

llvm/utils/lit/lit/llvm/config.py

577

Thoughts?

583

It's unfortunate that it's difficult in lit. I'm fine punting on that work for now, but I think we should try to invest in it (or are you saying "difficult" as in "not worth the effort"?)

[MaskRay]

address comments

[MaskRay]

clang/test/CodeGenCXX/exception-spec-decay.cpp

1

The proposal is probably clean if we the majority of tests work with C++98, but I think we have accrued many tests which don't work with C++98 so we need directives like %stdcxx_11-.

Since C++98 is actually uncommon now. I prefer explicit %stdcxx_98- to indicate a test works with C++98.

clang/test/CodeGenCXX/override-layout.cpp

1–14

Unfortunately, C++17 and C++20 have different behaviors. I haven't investigated why it is the case.

clang/test/Layout/ms-x86-vtordisp.cpp

1–3

This is similar to the previous -fdump-record-layouts test that the dump order is different across 14, 17, 20. I do now know whether there is something which should be improved to add the coverage.

For now I assume it is not this patch's responsibility to address it.

clang/test/SemaCXX/libstdcxx_is_pod_hack.cpp

1

This is a hack for presumably older language dialects. Switched to a range.

[MaskRay]

llvm/utils/lit/lit/llvm/config.py

574

Agree. This can be left as another patch.

583

I have asked for help on https://discourse.llvm.org/t/lit-run-a-run-line-multiple-times-with-different-replacements/64932

[aaron.ballman]

This LGTM but I'd appreciate it if @dblaikie could also give it a once over so we have more than one sets of eyes on the changes in case I've missed something.

clang/test/CodeGenCXX/exception-spec-decay.cpp

1

Since C++98 is actually uncommon now. I prefer explicit %stdcxx_98- to indicate a test works with C++98.

Heheh, there's still a *ton* of C++98 code out there, but I'm okay being explicit just the same (it makes the tests easier to read).

clang/test/CodeGenCXX/override-layout.cpp

1–14

Ah, that's fine to do in a follow-up then. Thanks!

clang/test/Layout/ms-x86-vtordisp.cpp

1–3

Agreed, thanks for the explanation!

[MaskRay]

Fix a test

clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify=c_mode   -ast-dump %s       | FileCheck %s --check-prefix=C
-// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify=cxx_mode -ast-dump %s -x c++| FileCheck %s --check-prefix=CXX
-
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify=cxx_mode -ast-dump %s -x c++ %stdcxx_11-14 | FileCheck %s --check-prefix=CXX
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify=cxx_mode,cxx17 -ast-dump %s -x c++ %stdcxx_17- | FileCheck %s --check-prefix=CXX
 // c_mode-no-diagnostics
 
 #ifdef __cplusplus
 #define CONST constexpr
 #else
 #define CONST __attribute__((const))
 #endif
 
 #pragma omp begin declare variant match(implementation = {vendor(llvm)})
 CONST int also_after1(void) { // cxx_mode-note {{previous declaration is here}}
   return 0;
 }
 static int also_after2(void) {
   return 0;
 }
-__attribute__((nothrow)) int also_after3(void) {
+__attribute__((nothrow)) int also_after3(void) { // cxx17-note {{previous declaration is here}}
   return 0;
 }
-static CONST __attribute__((nothrow, always_inline)) __inline__ int also_after4(void) { // cxx_mode-note {{previous declaration is here}}
+static CONST __attribute__((nothrow, always_inline)) __inline__ int also_after4(void) { // cxx_mode-note {{previous declaration is here}} cxx17-note {{previous declaration is here}}
   return 0;
 }
 #pragma omp end declare variant
 
 int also_after1(void) { // cxx_mode-error {{non-constexpr declaration of 'also_after1' follows constexpr declaration}}
   return 1;
 }
 int also_after2(void) {
   return 2;
 }
-int also_after3(void) {
+int also_after3(void) { // cxx17-warning {{'also_after3' is missing exception specification '__attribute__((nothrow))'}}
   return 3;
 }
-int also_after4(void) { // cxx_mode-error {{non-constexpr declaration of 'also_after4' follows constexpr declaration}}
+int also_after4(void) { // cxx_mode-error {{non-constexpr declaration of 'also_after4' follows constexpr declaration}} cxx17-warning {{'also_after4' is missing exception specification '__attribute__((nothrow))'}}
   return 4;
 }
 
 
 int main(void) {
   // Should return 0.
   return also_after1() + also_after2() + also_after3() + also_after4();
 }

clang/test/AST/ast-dump-openmp-begin-declare-variant_template_3.cpp

-// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify -ast-dump %s -x c++| FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify -ast-dump %s %stdcxx_11-14 | FileCheck %s --check-prefixes=CHECK,CXX11
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify -ast-dump %s %stdcxx_17- | FileCheck %s --check-prefixes=CHECK,CXX17
 // expected-no-diagnostics
 // PR47655
-
 template <typename T> struct S {
   S(int, T *) {}
 };
 
 template <typename T>
 int also_before(T s) {
   return 0;
 }

 // CHECK-NEXT: | |-TemplateTypeParmDecl [[ADDR_1:0x[a-z0-9]*]] <col:11, col:20> col:20 referenced typename depth 0 index 0 T
 // CHECK-NEXT: | |-CXXRecordDecl [[ADDR_2:0x[a-z0-9]*]] <col:23, line:7:1> line:5:30 struct S definition
 // CHECK-NEXT: | | |-DefinitionData empty standard_layout trivially_copyable has_user_declared_ctor can_const_default_init
 // CHECK-NEXT: | | | |-DefaultConstructor defaulted_is_constexpr
 // CHECK-NEXT: | | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT: | | | |-MoveConstructor exists simple trivial needs_implicit
 // CHECK-NEXT: | | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT: | | | |-MoveAssignment exists simple trivial needs_implicit
-// CHECK-NEXT: | | | `-Destructor simple irrelevant trivial needs_implicit
+// CHECK-NEXT: | | | `-Destructor simple irrelevant trivial {{(constexpr )?}}needs_implicit
 // CHECK-NEXT: | | |-CXXRecordDecl [[ADDR_3:0x[a-z0-9]*]] <col:23, col:30> col:30 implicit referenced struct S
 // CHECK-NEXT: | | `-CXXConstructorDecl [[ADDR_4:0x[a-z0-9]*]] <line:6:3, col:16> col:3 S<T> 'void (int, T *)'
 // CHECK-NEXT: | |   |-ParmVarDecl [[ADDR_5:0x[a-z0-9]*]] <col:5> col:8 'int'
 // CHECK-NEXT: | |   |-ParmVarDecl [[ADDR_6:0x[a-z0-9]*]] <col:10, col:12> col:13 'T *'
 // CHECK-NEXT: | |   `-CompoundStmt [[ADDR_7:0x[a-z0-9]*]] <col:15, col:16>
 // CHECK-NEXT: | |-ClassTemplateSpecializationDecl [[ADDR_8:0x[a-z0-9]*]] <line:5:1, line:7:1> line:5:30 struct S definition
 // CHECK-NEXT: | | |-DefinitionData pass_in_registers empty standard_layout trivially_copyable has_user_declared_ctor can_const_default_init
 // CHECK-NEXT: | | | |-DefaultConstructor defaulted_is_constexpr
 // CHECK-NEXT: | | | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
 // CHECK-NEXT: | | | |-MoveConstructor exists simple trivial
 // CHECK-NEXT: | | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT: | | | |-MoveAssignment exists simple trivial needs_implicit
 // CHECK-NEXT: | | | `-Destructor simple irrelevant trivial
 // CHECK-NEXT: | | |-TemplateArgument type 'int'
 // CHECK-NEXT: | | | `-BuiltinType [[ADDR_9:0x[a-z0-9]*]] 'int'
 // CHECK-NEXT: | | |-CXXRecordDecl [[ADDR_10:0x[a-z0-9]*]] <col:23, col:30> col:30 implicit struct S
 // CHECK-NEXT: | | |-CXXConstructorDecl [[ADDR_11:0x[a-z0-9]*]] <line:6:3, col:16> col:3 used S 'void (int, int *)'
 // CHECK-NEXT: | | | |-ParmVarDecl [[ADDR_12:0x[a-z0-9]*]] <col:5> col:8 'int'
 // CHECK-NEXT: | | | |-ParmVarDecl [[ADDR_13:0x[a-z0-9]*]] <col:10, col:12> col:13 'int *'
 // CHECK-NEXT: | | | `-CompoundStmt [[ADDR_7]] <col:15, col:16>
 // CHECK-NEXT: | | |-CXXConstructorDecl [[ADDR_14:0x[a-z0-9]*]] <line:5:30> col:30 implicit constexpr S 'void (const S<int> &)' inline default trivial noexcept-unevaluated [[ADDR_14]]
 // CHECK-NEXT: | | | `-ParmVarDecl [[ADDR_15:0x[a-z0-9]*]] <col:30> col:30 'const S<int> &'
-// CHECK-NEXT: | | |-CXXConstructorDecl [[ADDR_16:0x[a-z0-9]*]] <col:30> col:30 implicit used constexpr S 'void (S<int> &&) noexcept' inline default trivial
-// CHECK-NEXT: | | | |-ParmVarDecl [[ADDR_17:0x[a-z0-9]*]] <col:30> col:30 'S<int> &&'
-// CHECK-NEXT: | | | `-CompoundStmt [[ADDR_18:0x[a-z0-9]*]] <col:30>
-// CHECK-NEXT: | | `-CXXDestructorDecl [[ADDR_19:0x[a-z0-9]*]] <col:30> col:30 implicit referenced ~S 'void ({{.*}}) noexcept' inline default trivial
+// CXX11-NEXT: | | |-CXXConstructorDecl [[ADDR_16:0x[a-z0-9]*]] <col:30> col:30 implicit used constexpr S 'void (S<int> &&) noexcept' inline default trivial
+// CXX11-NEXT: | | | |-ParmVarDecl [[ADDR_17:0x[a-z0-9]*]] <col:30> col:30 'S<int> &&'
+// CXX11-NEXT: | | | `-CompoundStmt [[ADDR_18:0x[a-z0-9]*]] <col:30>
+// CXX17-NEXT: | | |-CXXConstructorDecl [[ADDR_16:0x[a-z0-9]*]] <col:30> col:30 implicit constexpr S 'void (S<int> &&)' inline default trivial noexcept-unevaluated
+// CXX17-NEXT: | | | `-ParmVarDecl [[ADDR_17:0x[a-z0-9]*]] <col:30> col:30 'S<int> &&'
+// CHECK-NEXT: | | `-CXXDestructorDecl [[ADDR_19:0x[a-z0-9]*]] <col:30> col:30 implicit referenced {{(constexpr )?}}~S 'void ({{.*}}) noexcept' inline default trivial
 // CHECK-NEXT: | `-ClassTemplateSpecializationDecl [[ADDR_20:0x[a-z0-9]*]] <col:1, line:7:1> line:5:30 struct S
 // CHECK-NEXT: |   `-TemplateArgument type 'double'
 // CHECK-NEXT: |     `-BuiltinType [[ADDR_21:0x[a-z0-9]*]] 'double'
 // CHECK-NEXT: |-FunctionTemplateDecl [[ADDR_22:0x[a-z0-9]*]] <line:9:1, line:12:1> line:10:5 also_before
 // CHECK-NEXT: | |-TemplateTypeParmDecl [[ADDR_23:0x[a-z0-9]*]] <line:9:11, col:20> col:20 referenced typename depth 0 index 0 T
 // CHECK-NEXT: | |-FunctionDecl [[ADDR_24:0x[a-z0-9]*]] <line:10:1, line:12:1> line:10:5 also_before 'int (T)'
 // CHECK-NEXT: | | |-ParmVarDecl [[ADDR_25:0x[a-z0-9]*]] <col:17, col:19> col:19 s 'T'
 // CHECK-NEXT: | | |-CompoundStmt [[ADDR_26:0x[a-z0-9]*]] <col:22, line:12:1>

 // CHECK-NEXT: |   | `-BuiltinType [[ADDR_21]] 'double'
 // CHECK-NEXT: |   |-ParmVarDecl [[ADDR_123:0x[a-z0-9]*]] <col:16, col:18> col:18 s 'double':'double'
 // CHECK-NEXT: |   `-CompoundStmt [[ADDR_124:0x[a-z0-9]*]] <col:21, line:40:1>
 // CHECK-NEXT: |     `-ReturnStmt [[ADDR_125:0x[a-z0-9]*]] <line:39:3, col:10>
 // CHECK-NEXT: |       `-IntegerLiteral [[ADDR_117]] <col:10> 'int' 0
 // CHECK-NEXT: `-FunctionDecl [[ADDR_126:0x[a-z0-9]*]] <line:42:1, line:45:1> line:42:5 test 'int ({{.*}})'
 // CHECK-NEXT:   `-CompoundStmt [[ADDR_127:0x[a-z0-9]*]] <col:12, line:45:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_128:0x[a-z0-9]*]] <line:44:3, col:98>
-// CHECK-NEXT:       `-ExprWithCleanups [[ADDR_129:0x[a-z0-9]*]] <col:10, col:98> 'int'
+// CXX11-NEXT:       `-ExprWithCleanups [[ADDR_129:0x[a-z0-9]*]] <col:10, col:98> 'int'
 // CHECK-NEXT:         `-BinaryOperator [[ADDR_130:0x[a-z0-9]*]] <col:10, col:98> 'int' '+'
 // CHECK-NEXT:           |-BinaryOperator [[ADDR_131:0x[a-z0-9]*]] <col:10, col:74> 'int' '+'
 // CHECK-NEXT:           | |-BinaryOperator [[ADDR_132:0x[a-z0-9]*]] <col:10, col:57> 'int' '+'
 // CHECK-NEXT:           | | |-BinaryOperator [[ADDR_133:0x[a-z0-9]*]] <col:10, col:39> 'int' '+'
 // CHECK-NEXT:           | | | |-CallExpr [[ADDR_134:0x[a-z0-9]*]] <col:10, col:23> 'int'
 // CHECK-NEXT:           | | | | |-ImplicitCastExpr [[ADDR_135:0x[a-z0-9]*]] <col:10> 'int (*)(int)' <FunctionToPointerDecay>
 // CHECK-NEXT:           | | | | | `-DeclRefExpr [[ADDR_136:0x[a-z0-9]*]] <col:10> 'int (int)' {{.*}}Function [[ADDR_32]] 'also_before' 'int (int)' (FunctionTemplate [[ADDR_22]] 'also_before')
 // CHECK-NEXT:           | | | | `-IntegerLiteral [[ADDR_137:0x[a-z0-9]*]] <col:22> 'int' 0
 // CHECK-NEXT:           | | | `-CallExpr [[ADDR_138:0x[a-z0-9]*]] <col:27, col:39> 'int'
 // CHECK-NEXT:           | | |   |-ImplicitCastExpr [[ADDR_139:0x[a-z0-9]*]] <col:27> 'int (*)(int)' <FunctionToPointerDecay>
 // CHECK-NEXT:           | | |   | `-DeclRefExpr [[ADDR_140:0x[a-z0-9]*]] <col:27> 'int (int)' {{.*}}Function [[ADDR_118]] 'also_after' 'int (int)' (FunctionTemplate [[ADDR_111]] 'also_after')
 // CHECK-NEXT:           | | |   `-IntegerLiteral [[ADDR_141:0x[a-z0-9]*]] <col:38> 'int' 0
 // CHECK-NEXT:           | | `-CallExpr [[ADDR_142:0x[a-z0-9]*]] <col:43, col:57> 'int'
 // CHECK-NEXT:           | |   |-ImplicitCastExpr [[ADDR_143:0x[a-z0-9]*]] <col:43> 'int (*)(double)' <FunctionToPointerDecay>
 // CHECK-NEXT:           | |   | `-DeclRefExpr [[ADDR_144:0x[a-z0-9]*]] <col:43> 'int (double)' {{.*}}Function [[ADDR_36]] 'also_before' 'int (double)' (FunctionTemplate [[ADDR_22]] 'also_before')
 // CHECK-NEXT:           | |   `-FloatingLiteral [[ADDR_145:0x[a-z0-9]*]] <col:55> 'double' 0.000000e+00
 // CHECK-NEXT:           | `-CallExpr [[ADDR_146:0x[a-z0-9]*]] <col:61, col:74> 'int'
 // CHECK-NEXT:           |   |-ImplicitCastExpr [[ADDR_147:0x[a-z0-9]*]] <col:61> 'int (*)(double)' <FunctionToPointerDecay>
 // CHECK-NEXT:           |   | `-DeclRefExpr [[ADDR_148:0x[a-z0-9]*]] <col:61> 'int (double)' {{.*}}Function [[ADDR_122]] 'also_after' 'int (double)' (FunctionTemplate [[ADDR_111]] 'also_after')
 // CHECK-NEXT:           |   `-FloatingLiteral [[ADDR_149:0x[a-z0-9]*]] <col:72> 'double' 0.000000e+00
 // CHECK-NEXT:           `-PseudoObjectExpr [[ADDR_150:0x[a-z0-9]*]] <col:78, col:98> 'int'
 // CHECK-NEXT:             |-CallExpr [[ADDR_151:0x[a-z0-9]*]] <col:78, col:98> 'int'
 // CHECK-NEXT:             | |-ImplicitCastExpr [[ADDR_152:0x[a-z0-9]*]] <col:78> 'int (*)(S<int>)' <FunctionToPointerDecay>
 // CHECK-NEXT:             | | `-DeclRefExpr [[ADDR_153:0x[a-z0-9]*]] <col:78> 'int (S<int>)' {{.*}}Function [[ADDR_65]] 'special' 'int (S<int>)' (FunctionTemplate [[ADDR_58]] 'special')
-// CHECK-NEXT:             | `-CXXConstructExpr [[ADDR_154:0x[a-z0-9]*]] <col:86, col:97> 'S<int>':'S<int>' 'void (S<int> &&) noexcept' elidable
-// CHECK-NEXT:             |   `-MaterializeTemporaryExpr [[ADDR_155:0x[a-z0-9]*]] <col:86, col:97> 'S<int>':'S<int>' xvalue
+// CXX11-NEXT:             | `-CXXConstructExpr [[ADDR_154:0x[a-z0-9]*]] <col:86, col:97> 'S<int>':'S<int>' 'void (S<int> &&) noexcept' elidable
+// CXX11-NEXT:             |   `-MaterializeTemporaryExpr [[ADDR_155:0x[a-z0-9]*]] <col:86, col:97> 'S<int>':'S<int>' xvalue
 // CHECK-NEXT:             |     `-CXXTemporaryObjectExpr [[ADDR_156:0x[a-z0-9]*]] <col:86, col:97> 'S<int>':'S<int>' 'void (int, int *)'
 // CHECK-NEXT:             |       |-IntegerLiteral [[ADDR_157:0x[a-z0-9]*]] <col:93> 'int' 0
 // CHECK-NEXT:             |       `-ImplicitCastExpr [[ADDR_158:0x[a-z0-9]*]] <col:96> 'int *' <NullToPointer>
 // CHECK-NEXT:             |         `-IntegerLiteral [[ADDR_159:0x[a-z0-9]*]] <col:96> 'int' 0
 // CHECK-NEXT:             `-CallExpr [[ADDR_160:0x[a-z0-9]*]] <line:23:1, line:44:98> 'int'
 // CHECK-NEXT:               |-ImplicitCastExpr [[ADDR_161:0x[a-z0-9]*]] <line:23:1> 'int (*)(S<int>)' <FunctionToPointerDecay>
 // CHECK-NEXT:               | `-DeclRefExpr [[ADDR_68]] <col:1> 'int (S<int>)' {{.*}}Function [[ADDR_69]] 'special[implementation={extension(allow_templates)}]' 'int (S<int>)'
-// CHECK-NEXT:               `-CXXConstructExpr [[ADDR_162:0x[a-z0-9]*]] <line:44:86, col:97> 'S<int>':'S<int>' 'void (S<int> &&) noexcept' elidable
-// CHECK-NEXT:                 `-MaterializeTemporaryExpr [[ADDR_163:0x[a-z0-9]*]] <col:86, col:97> 'S<int>':'S<int>' xvalue
-// CHECK-NEXT:                   `-CXXTemporaryObjectExpr [[ADDR_156]] <col:86, col:97> 'S<int>':'S<int>' 'void (int, int *)'
+// CXX11-NEXT:               `-CXXConstructExpr [[ADDR_162:0x[a-z0-9]*]] <line:44:86, col:97> 'S<int>':'S<int>' 'void (S<int> &&) noexcept' elidable
+// CXX11-NEXT:                 `-MaterializeTemporaryExpr [[ADDR_163:0x[a-z0-9]*]] <col:86, col:97> 'S<int>':'S<int>' xvalue
+// CXX11-NEXT:                   `-CXXTemporaryObjectExpr [[ADDR_156]] <col:86, col:97> 'S<int>':'S<int>' 'void (int, int *)'
+// CXX17-NEXT:                   `-CXXTemporaryObjectExpr [[ADDR_156]] <line:[[#]]:86, col:97> 'S<int>':'S<int>' 'void (int, int *)'
 // CHECK-NEXT:                     |-IntegerLiteral [[ADDR_157]] <col:93> 'int' 0
 // CHECK-NEXT:                     `-ImplicitCastExpr [[ADDR_158]] <col:96> 'int *' <NullToPointer>
 // CHECK-NEXT:                       `-IntegerLiteral [[ADDR_159]] <col:96> 'int' 0

clang/test/AST/ast-dump-undeduced-expr.cpp

 // RUN: not %clang_cc1 -triple x86_64-unknown-unknown -ast-dump %s | FileCheck %s
 
 struct Foo {
   static constexpr auto Bar = ;
 };
 
-// CHECK: -VarDecl {{.*}} invalid Bar 'const auto' static constexpr
+// CHECK: -VarDecl {{.*}} invalid Bar 'const auto' static {{(inline )?}}constexpr

clang/test/AST/sourceranges.cpp

-// RUN: %clang_cc1 -triple i686-mingw32 -ast-dump %s | FileCheck %s
-// RUN: %clang_cc1 -triple i686-mingw32 -std=c++1z -ast-dump %s | FileCheck %s -check-prefix=CHECK-1Z
+// RUN: %clang_cc1 -triple i686-mingw32 %stdcxx_11-14 -ast-dump %s | FileCheck %s
+// RUN: %clang_cc1 -triple i686-mingw32 %stdcxx_17- -ast-dump %s | FileCheck %s -check-prefix=CHECK-1Z
 
 template<class T>
 class P {
  public:
   P(T* t) {}
 };
 
 namespace foo {

clang/test/Analysis/blocks.m

 // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core -fblocks -verify -Wno-strict-prototypes %s
 // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core -fblocks -verify -x objective-c++ %s
 
 //===----------------------------------------------------------------------===//
 // The following code is reduced using delta-debugging from Mac OS X headers:
 //===----------------------------------------------------------------------===//
 
 typedef __builtin_va_list va_list;
 typedef unsigned int uint32_t;
 typedef struct dispatch_queue_s *dispatch_queue_t;
 typedef struct dispatch_queue_attr_s *dispatch_queue_attr_t;
 typedef void (^dispatch_block_t)(void);
 void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
 __attribute__((visibility("default"))) __attribute__((__malloc__)) __attribute__((__warn_unused_result__)) __attribute__((__nothrow__)) dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);
 typedef long dispatch_once_t;
 void dispatch_once(dispatch_once_t *predicate, dispatch_block_t block);
+#if __cplusplus >= 201703L
+__attribute__((__nothrow__))
+#endif
 dispatch_queue_t
 dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);
 
 
 typedef signed char BOOL;
 typedef unsigned long NSUInteger;
 typedef struct _NSZone NSZone;
 @class NSInvocation, NSMethodSignature, NSCoder, NSString, NSEnumerator;

clang/test/Analysis/exploded-graph-rewriter/objects_under_construction.cpp

 // FIXME: Figure out how to use %clang_analyze_cc1 with our lit.local.cfg.
-// RUN: %clang_cc1 -analyze -triple x86_64-unknown-linux-gnu \
+// RUN: %clang_cc1 -std=c++14 -analyze -triple x86_64-unknown-linux-gnu \
 // RUN:                     -analyze-function "test()" \
 // RUN:                     -analyzer-checker=core \
 // RUN:                     -analyzer-dump-egraph=%t.dot %s
 // RUN: %exploded_graph_rewriter %t.dot | FileCheck %s
 
 struct S {
   S() {}
 };

clang/test/CXX/basic/basic.stc/basic.stc.dynamic/p2.cpp

-// RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify -std=c++11 %s
-// RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify -Wno-dynamic-exception-spec %stdcxx_98- %s
 int *use_new(int N) {
   if (N == 1)
     return new int;
   
   return new int [N];
 }
 
 void use_delete(int* ip, int N) {
   if (N == 1)
     delete ip;
   else
     delete [] ip;
 }
 
 namespace std {
   class bad_alloc { };
   
   typedef __SIZE_TYPE__ size_t;
 }
 
 void* operator new(std::size_t) throw(std::bad_alloc);
 #if __cplusplus < 201103L
 // expected-note@-2 {{previous declaration}}
 #endif
+
 void* operator new[](std::size_t) throw(std::bad_alloc); 
 void operator delete(void*) throw(); // expected-note{{previous declaration}}
 void operator delete[](void*) throw();
 
 void* operator new(std::size_t);
 #if __cplusplus < 201103L
 // expected-warning@-2 {{'operator new' is missing exception specification 'throw(std::bad_alloc)'}}
 #endif
 void operator delete(void*);
 #if __cplusplus < 201103L
 // expected-warning@-2 {{'operator delete' is missing exception specification 'throw()'}}
 #else
 // expected-warning@-4 {{previously declared with an explicit exception specification redeclared with an implicit}}
 #endif

clang/test/CXX/class.access/class.friend/p1.cpp

 namespace test6 {
   struct A {};
 
   struct B {
     friend
 #if __cplusplus >= 201103L
       constexpr
 #endif
-      A::A();
+      A::A()
+#if __cplusplus >= 201703L
+      noexcept
+#endif
+      ;
     friend A::~A();
     friend
 #if __cplusplus >= 201402L
       constexpr
 #endif
-      A &A::operator=(const A&);
+      A &A::operator=(const A&)
+#if __cplusplus >= 201703L
+      noexcept
+#endif
+      ;
   };
 }
 
 namespace test7 {
   template <class T> struct X {
     X();
     ~X();
     void foo();
     void bar();
   };
 
   class A {
     friend void X<int>::foo();
     friend X<int>::X();
     friend
 #if __cplusplus >= 201103L
       constexpr
 #endif
-      X<int>::X(const X&);
+      X<int>::X(const X&)
+#if __cplusplus >= 201703L
+      noexcept
+#endif
+      ;
 
   private:
     A(); // expected-note 2 {{declared private here}}
   };
 
   template<> void X<int>::foo() {
     A a;
   }

clang/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p2.cpp

 #endif
 
 auto void af(); // expected-error {{illegal storage class on function}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
 #endif
 
 register int ro; // expected-error {{illegal storage class on file-scoped variable}}
-#if __cplusplus >= 201103L // C++11 or later
-// expected-warning@-2 {{'register' storage class specifier is deprecated}}
+#if __cplusplus >= 201703L
+// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
+#elif __cplusplus >= 201103L
+// expected-warning@-4 {{'register' storage class specifier is deprecated}}
 #endif
 
 register void rf(); // expected-error {{illegal storage class on function}}
 
 struct S {
   auto int ao; // expected-error {{storage class specified for a member declaration}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
 #endif
   auto void af(); // expected-error {{storage class specified for a member declaration}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
 #endif
 
   register int ro; // expected-error {{storage class specified for a member declaration}}
   register void rf(); // expected-error {{storage class specified for a member declaration}}
 };
 
 void foo(auto int ap, register int rp) {
-#if __cplusplus >= 201103L // C++11 or later
+#if __cplusplus >= 201703L
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
-// expected-warning@-3 {{'register' storage class specifier is deprecated}}
+// expected-error@-3 {{ISO C++17 does not allow 'register' storage class specifier}}
+#elif __cplusplus >= 201103L
+// expected-warning@-5 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
+// expected-warning@-6 {{'register' storage class specifier is deprecated}}
 #endif
   auto int abo;
 #if __cplusplus >= 201103L // C++11 or later
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
 #endif
   auto void abf(); // expected-error {{illegal storage class on function}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
 #endif
 
   register int rbo;
-#if __cplusplus >= 201103L // C++11 or later
-// expected-warning@-2 {{'register' storage class specifier is deprecated}}
+#if __cplusplus >= 201703L
+// expected-error@-2 {{ISO C++17 does not allow 'register' storage class specifier}}
+#elif __cplusplus >= 201103L
+// expected-warning@-4 {{'register' storage class specifier is deprecated}}
 #endif
 
   register void rbf(); // expected-error {{illegal storage class on function}}
 }

clang/test/CXX/except/except.spec/p2-dynamic-types.cpp

-// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -fsyntax-only -Wno-dynamic-exception-spec -verify %s
 
 // Dynamic specifications: valid types.
 
 struct Incomplete; // expected-note 3 {{forward declaration}}
 
 // Exception spec must not have incomplete types, or pointers to them, except
 // void.
 void ic1() throw(void); // expected-error {{incomplete type 'void' is not allowed in exception specification}}

clang/test/CXX/except/except.spec/p9-dynamic.cpp

-// RUN: %clang_cc1 -no-opaque-pointers %s -triple=x86_64-apple-darwin10 -emit-llvm -o - -fcxx-exceptions -fexceptions | FileCheck %s --check-prefixes=CHECK,CHECK-PRE17
-// RUN: %clang_cc1 -no-opaque-pointers %s -triple=x86_64-apple-darwin10 -std=c++17 -Wno-dynamic-exception-spec -emit-llvm -o - -fcxx-exceptions -fexceptions | FileCheck %s --check-prefixes=CHECK,CHECK-17
+// RUN: %clang_cc1 %stdcxx_98-14 -no-opaque-pointers %s -triple=x86_64-apple-darwin10 -emit-llvm -o - -fcxx-exceptions -fexceptions | FileCheck %s --check-prefixes=CHECK,CHECK-PRE17
+// RUN: %clang_cc1 %stdcxx_17- -no-opaque-pointers %s -triple=x86_64-apple-darwin10 -Wno-dynamic-exception-spec -emit-llvm -o - -fcxx-exceptions -fexceptions | FileCheck %s --check-prefixes=CHECK,CHECK-17
 
 void external();
 
 // CHECK-LABEL: _Z6targetv(
 // CHECK: invoke void @_Z8externalv()
 // CHECK:      landingpad { i8*, i32 }
 // CHECK-NEXT:   filter [1 x i8*] [i8* bitcast (i8** @_ZTIi to i8*)]
 // CHECK:      call void @__cxa_call_unexpected

clang/test/CXX/stmt.stmt/stmt.select/p3.cpp

-// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify %s
-// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -std=c++1z -Wc++14-compat -verify %s -DCPP17
+// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify %stdcxx_98-14 %s
+// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -Wc++14-compat -verify %stdcxx_17- %s -DCPP17
 
 int f();
 
 void g() {
   if (int x = f()) { // expected-note 2{{previous definition}}
     int x; // expected-error{{redefinition of 'x'}}
   } else {
     int x; // expected-error{{redefinition of 'x'}}

clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu %s
-// RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 -triple=x86_64-linux-gnu %stdcxx_98-14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx17 -triple=x86_64-linux-gnu %stdcxx_17- %s
 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -triple=x86_64-linux-gnu %s -DCPP11ONLY
 
 // C++11 [temp.arg.nontype]p1:
 //
 //   A template-argument for a non-type, non-template template-parameter shall
 //   be one of:
 //   -- an integral constant expression; or
 //   -- the name of a non-type template-parameter ; or

 //   -- a constant expression that designates the address of an object with
 //      static storage duration and external or internal linkage or a function
 //      with external or internal linkage, including function templates and
 //      function template-ids, but excluting non-static class members, expressed
 //      (ignoring parentheses) as & id-expression, except that the & may be
 //      omitted if the name refers to a function or array and shall be omitted
 //      if the corresopnding template-parameter is a reference; or
 namespace addr_of_obj_or_func {
-  template <int* p> struct X0 { }; // expected-note 5{{here}}
+  template <int* p> struct X0 { }; // precxx17-note 5{{here}}
 #if __cplusplus >= 201103L
-  // expected-note@-2 2{{template parameter is declared here}}
+  // precxx17-note@-2 2{{template parameter is declared here}}
 #endif
 
   template <int (*fp)(int)> struct X1 { };
-  template <int &p> struct X2 { }; // expected-note 4{{here}}
-  template <const int &p> struct X2k { }; // expected-note {{here}}
-  template <int (&fp)(int)> struct X3 { }; // expected-note 4{{here}}
+  template <int &p> struct X2 { }; // precxx17-note 4{{here}}
+  template <const int &p> struct X2k { }; // precxx17-note {{here}}
+  template <int (&fp)(int)> struct X3 { }; // precxx17-note 4{{here}}
 
   int i = 42;
 #if __cplusplus >= 201103L
-  // expected-note@-2 {{declared here}}
+  // precxx17-note@-2 {{declared here}}
 #endif
 
   int iarr[10];
   int f(int i);
   const int ki = 9;
 #if __cplusplus <= 199711L
   // expected-note@-2 5{{non-type template argument refers to object here}}
 #endif
 
-  __thread int ti = 100; // expected-note {{here}}
+  __thread int ti = 100; // precxx17-note {{here}}
 #if __cplusplus <= 199711L
-  // expected-note@-2 {{here}}
+  // precxx17-note@-2 {{here}}
 #endif
 
   static int f_internal(int);
 #if __cplusplus <= 199711L
   // expected-note@-2 4{{non-type template argument refers to function here}}
 #endif
 
   template <typename T> T f_tmpl(T t);
   struct S { union { int NonStaticMember; }; };
 
   void test() {
     X0<i> x0a;
 #if __cplusplus <= 199711L
     // expected-error@-2 {{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
 #else
-    // expected-error@-4 {{non-type template argument of type 'int' is not a constant expression}}
-    // expected-note@-5 {{read of non-const variable 'i' is not allowed in a constant expression}}
+    // precxx17-error@-4 {{non-type template argument of type 'int' is not a constant expression}}
+    // precxx17-note@-5 {{read of non-const variable 'i' is not allowed in a constant expression}}
+    // cxx17-error@-6 {{value of type 'int' is not implicitly convertible to 'int *'}}
 #endif
     X0<&i> x0a_addr;
     X0<iarr> x0b;
-    X0<&iarr> x0b_addr; // expected-error {{cannot be converted to a value of type 'int *'}}
-    X0<ki> x0c; // expected-error {{must have its address taken}}
+    X0<&iarr> x0b_addr; // precxx17-error {{cannot be converted to a value of type 'int *'}} cxx17-error {{value of type 'int (*)[10]' is not implicitly convertible to 'int *'}}
+    X0<ki> x0c; // precxx17-error {{must have its address taken}} cxx17-error {{value of type 'const int' is not implicitly convertible to 'int *'}}
 #if __cplusplus <= 199711L
     // expected-warning@-2 {{internal linkage is a C++11 extension}}
 #endif
 
-    X0<&ki> x0c_addr; // expected-error {{cannot be converted to a value of type 'int *'}}
+    X0<&ki> x0c_addr; // precxx17-error {{cannot be converted to a value of type 'int *'}} cxx17-error {{value of type 'const int *' is not implicitly convertible to 'int *'}}
 #if __cplusplus <= 199711L
     // expected-warning@-2 {{internal linkage is a C++11 extension}}
 #endif
 
     X0<&ti> x0d_addr;
 #if __cplusplus <= 199711L
     // expected-error@-2 {{non-type template argument refers to thread-local object}}
 #else
-    // expected-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
+    // precxx17-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
+    // cxx17-error@-5 {{on-type template argument is not a constant expression}}
 #endif
 
     X1<f> x1a;
     X1<&f> x1a_addr;
     X1<f_tmpl> x1b;
     X1<&f_tmpl> x1b_addr;
     X1<f_tmpl<int> > x1c;
     X1<&f_tmpl<int> > x1c_addr;
     X1<f_internal> x1d;
 #if __cplusplus <= 199711L
     // expected-warning@-2 {{internal linkage is a C++11 extension}}
 #endif
 
     X1<&f_internal> x1d_addr;
 #if __cplusplus <= 199711L
     // expected-warning@-2 {{internal linkage is a C++11 extension}}
 #endif
 
     X2<i> x2a;
-    X2<&i> x2a_addr; // expected-error {{address taken}}
-    X2<iarr> x2b; // expected-error {{cannot bind to template argument of type 'int[10]'}}
-    X2<&iarr> x2b_addr; // expected-error {{address taken}}
-    X2<ki> x2c; // expected-error {{ignores qualifiers}}
+    X2<&i> x2a_addr; // precxx17-error {{address taken}} cxx17-error {{value of type 'int *' is not implicitly convertible to 'int &'}}
+    X2<iarr> x2b; // precxx17-error {{cannot bind to template argument of type 'int[10]'}} cxx17-error {{value of type 'int[10]' is not implicitly convertible to 'int &'}}
+    X2<&iarr> x2b_addr; // precxx17-error {{address taken}} cxx17-error {{value of type 'int (*)[10]' is not implicitly convertible to 'int &'}}
+    X2<ki> x2c; // precxx17-error {{ignores qualifiers}} cxx17-error {{value of type 'const int' is not implicitly convertible to 'int &'}}
 #if __cplusplus <= 199711L
     // expected-warning@-2 {{internal linkage is a C++11 extension}}
 #endif
 
     X2k<ki> x2kc;
 #if __cplusplus <= 199711L
     // expected-warning@-2 {{internal linkage is a C++11 extension}}
 #endif
 
-    X2k<&ki> x2kc_addr; // expected-error {{address taken}}
+    X2k<&ki> x2kc_addr; // precxx17-error {{address taken}} cxx17-error {{value of type 'const int *' is not implicitly convertible to 'const int &'}}
 #if __cplusplus <= 199711L
     // expected-warning@-2 {{internal linkage is a C++11 extension}}
 #endif
 
-    X2<ti> x2d_addr; // expected-error {{refers to thread-local object}}
+    X2<ti> x2d_addr; // precxx17-error {{refers to thread-local object}} cxx17-error {{non-type template argument is not a constant expression}}
     X3<f> x3a;
-    X3<&f> x3a_addr; // expected-error {{address taken}}
+    X3<&f> x3a_addr; // precxx17-error {{address taken}} cxx17-error {{value of type 'int (*)(int)' is not implicitly convertible to 'int (&)(int)'}}
     X3<f_tmpl> x3b;
-    X3<&f_tmpl> x3b_addr; // expected-error {{address taken}}
+    X3<&f_tmpl> x3b_addr; // precxx17-error {{address taken}} cxx17-error {{value of type '<overloaded function type>' is not implicitly convertible to 'int (&)(int)'}}
     X3<f_tmpl<int> > x3c;
-    X3<&f_tmpl<int> > x3c_addr; // expected-error {{address taken}}
+    X3<&f_tmpl<int> > x3c_addr; // precxx17-error {{address taken}} cxx17-error {{value of type '<overloaded function type>' is not implicitly convertible to 'int (&)(int)'}}
     X3<f_internal> x3d;
 #if __cplusplus <= 199711L
     // expected-warning@-2 {{internal linkage is a C++11 extension}}
 #endif
 
-    X3<&f_internal> x3d_addr; // expected-error {{address taken}}
+    X3<&f_internal> x3d_addr; // precxx17-error {{address taken}} cxx17-error {{value of type 'int (*)(int)' is not implicitly convertible to 'int (&)(int)'}}
 #if __cplusplus <= 199711L
     // expected-warning@-2 {{internal linkage is a C++11 extension}}
 #endif
 
     int n;
 #if __cplusplus <= 199711L
     // expected-note@-2 {{non-type template argument refers to object here}}
 #else
     // expected-note@-4 {{declared here}}
 #endif
 
     X0<&n> x0_no_linkage;
 #if __cplusplus <= 199711L
     // expected-error@-2 {{non-type template argument refers to object 'n' that does not have linkage}}
 #else
-    // expected-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
-    // expected-note@-5 {{pointer to 'n' is not a constant expression}}
+    // precxx17-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
+    // cxx17-error@-5 {{non-type template argument is not a constant expression}}
+    // expected-note@-6 {{pointer to 'n' is not a constant expression}}
 #endif
 
-    struct Local { static int f() {} }; // expected-note {{here}}
-    X1<&Local::f> x1_no_linkage; // expected-error {{non-type template argument refers to function 'f' that does not have linkage}}
-    X0<&S::NonStaticMember> x0_non_static; // expected-error {{non-static data member}}
+    struct Local { static int f() {} }; // precxx17-note {{here}}
+    X1<&Local::f> x1_no_linkage; // precxx17-error {{non-type template argument refers to function 'f' that does not have linkage}} cxx17-error {{value of type 'int (*)()' is not implicitly convertible to 'int (*)(int)'}}
+    X0<&S::NonStaticMember> x0_non_static; // precxx17-error {{non-static data member}} cxx17-error {{value of type 'int addr_of_obj_or_func::S::*' is not implicitly convertible to 'int *'}}
   }
 }
 
 //   -- a constant expression that evaluates to a null pointer value (4.10); or
 //   -- a constant expression that evaluates to a null member pointer value
 //      (4.11); or
 //   -- a pointer to member expressed as described in 5.3.1.
 
 namespace bad_args {
-  template <int* N> struct X0 { }; // expected-note 2{{template parameter is declared here}}
+  template <int* N> struct X0 { }; // precxx17-note 2{{template parameter is declared here}}
   int i = 42;
-  X0<&i + 2> x0a; // expected-error{{non-type template argument does not refer to any declaration}}
+  X0<&i + 2> x0a; // precxx17-error{{non-type template argument does not refer to any declaration}} \
+                     cxx17-error {{non-type template argument is not a constant expression}} \
+                     cxx17-note {{cannot refer to element 2 of non-array object in a constant expression}}
   int* iptr = &i;
 #if __cplusplus >= 201103L
   // expected-note@-2 {{declared here}}
 #endif
 
   X0<iptr> x0b;
 #if __cplusplus <= 199711L
   // expected-error@-2 {{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
 #else
-  // expected-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
-  // expected-note@-5 {{read of non-constexpr variable 'iptr' is not allowed in a constant expression}}
+  // precxx17-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
+  // cxx17-error@-5 {{non-type template argument is not a constant expression}}
+  // expected-note@-6 {{read of non-constexpr variable 'iptr' is not allowed in a constant expression}}
 #endif
 }
 #endif // CPP11ONLY
 
 namespace default_args {
 #ifdef CPP11ONLY
 namespace lambdas {
 template<int I = ([] { return 5; }())> //expected-error {{constant expression}}
 int f();
 }
 #endif // CPP11ONLY
 
 }

clang/test/CXX/temp/temp.res/temp.local/p3.cpp

-// RUN: %clang_cc1 -verify %s
+// RUN: %clang_cc1 -verify=expected,precxx17 %stdcxx_98-14 %s
+// RUN: %clang_cc1 -verify=expected,cxx17 %stdcxx_17- %s
 
 template <class T> struct Base {
   // expected-note@-1 2{{member type 'Base<int>' found by ambiguous name lookup}}
   // expected-note@-2 2{{member type 'Base<char>' found by ambiguous name lookup}}
   static void f();
 };
 
 struct X0 { };

 };
 
 namespace PR6717 {
   template <typename T>
   class WebVector {
   } // expected-error {{expected ';' after class}}
 
     WebVector(const WebVector<T>& other) { } // expected-error{{undeclared identifier 'T'}} \
-                                                expected-error{{a type specifier is required}}
+                                                precxx17-error{{a type specifier is required}} \
+                                                cxx17-error{{deduction guide declaration without trailing return type}} \
+                                                cxx17-error{{deduction guide cannot have a function definition}}
 
   template <typename C>
   WebVector<T>& operator=(const C& other) { } // expected-error{{undeclared identifier 'T'}}
 }

clang/test/CodeGen/typedef_alignment_mismatch_warning.cpp

-// RUN: %clang_cc1 %s -fsyntax-only -verify -fdata-sections -fcolor-diagnostics
+// RUN: %clang_cc1 %s -fsyntax-only -verify=expected,precxx17 %stdcxx_11-14 -fdata-sections -fcolor-diagnostics
+// RUN: %clang_cc1 %s -fsyntax-only -verify %stdcxx_17- -fdata-sections -fcolor-diagnostics
 
 // Warn for any function that
 //   * takes a pointer or a reference to an object (including "this" pointer),
 //   * that was defined for aligned object,
 //   * but is called with a pointer or reference to a less aligned object.
 // Attributes on using declarations are ignored.
 
 typedef __attribute__((aligned(2))) int Aligned2Int;
void test8() {
   auto SA8c = SA8a + SA8b;
   auto SA8d = SA8a - &SA8b;
   ++SA8c;
   --SA8d;
   TypedefAligned4 TA8a(11);            // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
   TypedefAligned4 TA8b(11);            // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
   TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}}
                                        // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
-                                       // expected-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+                                       // precxx17-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
   TypedefAligned4 TA8d = TA8a - &TA8b; // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator-' may result in an unaligned pointer access}}
                                        // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator-' may result in an unaligned pointer access}}
-                                       // expected-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+                                       // precxx17-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
   ++TA8d;                              // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator++' may result in an unaligned pointer access}}
   --TA8c;                              // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator--' may result in an unaligned pointer access}}
   UsingAligned4 UA8a(11);
   UsingAligned4 UA8b(11);
   auto UA8c = UA8a + UA8b;
   auto UA8d = UA8a - &UA8b;
   ++UA8c;
   --UA8d;

clang/test/CodeGenCXX/align-avx-complete-objects.cpp

-// RUN: %clang_cc1 -no-opaque-pointers -x c++ %s -O0 -triple=x86_64-apple-darwin -target-feature +avx2 -fmax-type-align=16 -emit-llvm -o - -Werror | FileCheck %s
+// RUN: %clang_cc1 -no-opaque-pointers %stdcxx_11-14 %s -O0 -triple=x86_64-apple-darwin -target-feature +avx2 -fmax-type-align=16 -emit-llvm -o - -Werror | FileCheck %s --check-prefixes=CHECK,PRE17
+// RUN: %clang_cc1 -no-opaque-pointers %stdcxx_17- %s -O0 -triple=x86_64-apple-darwin -target-feature +avx2 -fmax-type-align=16 -emit-llvm -o - -Werror | FileCheck %s --check-prefixes=CHECK,CXX17
 // rdar://16254558
 
 typedef float AVX2Float __attribute__((__vector_size__(32)));
 
 
-volatile float TestAlign(void)
+#if __cplusplus < 202002L
+volatile
+#endif
+float TestAlign(void)
 {
        volatile AVX2Float *p = new AVX2Float;
         *p = *p;
         AVX2Float r = *p;
         return r[0];
 }
 
 // CHECK: [[R:%.*]] = alloca <8 x float>, align 32
-// CHECK-NEXT:  [[CALL:%.*]] = call noalias noundef nonnull i8* @_Znwm(i64 noundef 32)
+// PRE17-NEXT:  [[CALL:%.*]] = call noalias noundef nonnull i8* @_Znwm(i64 noundef 32)
+// CXX17-NEXT:  [[CALL:%.*]] = call noalias noundef nonnull align 32 i8* @_ZnwmSt11align_val_t(i64 noundef 32, i64 noundef 32)
 // CHECK-NEXT:  [[ZERO:%.*]] = bitcast i8* [[CALL]] to <8 x float>*
 // CHECK-NEXT:  store <8 x float>* [[ZERO]], <8 x float>** [[P:%.*]], align 8
 // CHECK-NEXT:  [[ONE:%.*]] = load <8 x float>*, <8 x float>** [[P]], align 8
 // CHECK-NEXT:  [[TWO:%.*]] = load volatile <8 x float>, <8 x float>* [[ONE]], align 16
 // CHECK-NEXT:  [[THREE:%.*]] = load <8 x float>*, <8 x float>** [[P]], align 8
 // CHECK-NEXT:  store volatile <8 x float> [[TWO]], <8 x float>* [[THREE]], align 16
 // CHECK-NEXT:  [[FOUR:%.*]] = load <8 x float>*, <8 x float>** [[P]], align 8
 // CHECK-NEXT:  [[FIVE:%.*]] = load volatile <8 x float>, <8 x float>* [[FOUR]], align 16
 // CHECK-NEXT:  store <8 x float> [[FIVE]], <8 x float>* [[R]], align 32
 // CHECK-NEXT:  [[SIX:%.*]] = load <8 x float>, <8 x float>* [[R]], align 32
 // CHECK-NEXT:  [[VECEXT:%.*]] = extractelement <8 x float> [[SIX]], i32 0
 // CHECK-NEXT:  ret float [[VECEXT]]
 
 typedef float AVX2Float_Explicitly_aligned __attribute__((__vector_size__(32))) __attribute__((aligned (32)));
 
 typedef AVX2Float_Explicitly_aligned AVX2Float_indirect;
 
 typedef AVX2Float_indirect AVX2Float_use_existing_align;
 
-volatile float TestAlign2(void)
+#if __cplusplus < 202002L
+volatile
+#endif
+float TestAlign2(void)
 {
        volatile AVX2Float_use_existing_align *p = new AVX2Float_use_existing_align;
         *p = *p;
         AVX2Float_use_existing_align r = *p;
         return r[0];
 }
 
 // CHECK: [[R:%.*]] = alloca <8 x float>, align 32
-// CHECK-NEXT:  [[CALL:%.*]] = call noalias noundef nonnull i8* @_Znwm(i64 noundef 32)
+// PRE17-NEXT:  [[CALL:%.*]] = call noalias noundef nonnull i8* @_Znwm(i64 noundef 32)
+// CXX17-NEXT:  [[CALL:%.*]] = call noalias noundef nonnull align 32 i8* @_ZnwmSt11align_val_t(i64 noundef 32, i64 noundef 32)
 // CHECK-NEXT:  [[ZERO:%.*]] = bitcast i8* [[CALL]] to <8 x float>*
 // CHECK-NEXT:  store <8 x float>* [[ZERO]], <8 x float>** [[P:%.*]], align 8
 // CHECK-NEXT:  [[ONE:%.*]] = load <8 x float>*, <8 x float>** [[P]], align 8
 // CHECK-NEXT:  [[TWO:%.*]] = load volatile <8 x float>, <8 x float>* [[ONE]], align 32
 // CHECK-NEXT:  [[THREE:%.*]] = load <8 x float>*, <8 x float>** [[P]], align 8
 // CHECK-NEXT:  store volatile <8 x float> [[TWO]], <8 x float>* [[THREE]], align 32
 // CHECK-NEXT:  [[FOUR:%.*]] = load <8 x float>*, <8 x float>** [[P]], align 8
 // CHECK-NEXT:  [[FIVE:%.*]] = load volatile <8 x float>, <8 x float>* [[FOUR]], align 32
 // CHECK-NEXT:  store <8 x float> [[FIVE]], <8 x float>* [[R]], align 32
 // CHECK-NEXT:  [[SIX:%.*]] = load <8 x float>, <8 x float>* [[R]], align 32
 // CHECK-NEXT:  [[VECEXT:%.*]] = extractelement <8 x float> [[SIX]], i32 0
 // CHECK-NEXT:  ret float [[VECEXT]]

clang/test/CodeGenCXX/copy-constructor-elim-2.cpp

-// RUN: %clang_cc1 -no-opaque-pointers -no-enable-noundef-analysis -triple armv7-none-eabi -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 %stdcxx_11-14 -no-opaque-pointers -no-enable-noundef-analysis -triple armv7-none-eabi -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,PRE17
+// RUN: %clang_cc1 %stdcxx_17- -no-opaque-pointers -no-enable-noundef-analysis -triple armv7-none-eabi -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,CXX17
 
 struct A { int x; A(int); ~A(); };
 A f() { return A(0); }
 // CHECK-LABEL: define{{.*}} void @_Z1fv
 // CHECK: call {{.*}} @_ZN1AC1Ei
 // CHECK-NEXT: ret void
 
-// Verify that we do not elide copies when constructing a base class.
+// Verify that we do not elide copies when constructing a base class before C++17.
 namespace no_elide_base {
   struct Base { 
     Base(const Base&);
     ~Base();
   };
 
   struct Other {
     operator Base() const;
   };
 
   struct Derived : public virtual Base { 
     Derived(const Other &O);
   };
 
   // CHECK: define {{.*}} @_ZN13no_elide_base7DerivedC1ERKNS_5OtherE(%"struct.no_elide_base::Derived"* {{[^,]*}} returned {{[^,]*}} %this, %"struct.no_elide_base::Other"* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %O) unnamed_addr
   Derived::Derived(const Other &O) 
     // CHECK: call {{.*}} @_ZNK13no_elide_base5OthercvNS_4BaseEEv
-    // CHECK: call {{.*}} @_ZN13no_elide_base4BaseC2ERKS0_
-    // CHECK: call {{.*}} @_ZN13no_elide_base4BaseD1Ev
+    // PRE17: call {{.*}} @_ZN13no_elide_base4BaseC2ERKS0_
+    // PRE17: call {{.*}} @_ZN13no_elide_base4BaseD1Ev
+    // CXX17-NOT: call
     : Base(O)
   {
     // CHECK: ret
   }
 }
 
 // PR8683.
 

 namespace ElidableCallIsNotCopyCtor {
   struct A { A(const A&); };
   struct B : A {
     B(B&);
     B(A);
     B(int);
   };
   void f() {
-    // Here, we construct via B(int) then B(A). The B(A) construction is
+    // Before C++17, we construct via B(int) then B(A). The B(A) construction is
     // elidable, but we don't have an AST representation for the case where we
     // must elide not only a constructor call but also some argument
     // conversions, so we don't elide it.
     // CHECK-LABEL: define{{.*}} void @_ZN25ElidableCallIsNotCopyCtor1fEv(
     // CHECK: call {{.*}} @_ZN25ElidableCallIsNotCopyCtor1BC1Ei(
-    // CHECK: call {{.*}} @_ZN25ElidableCallIsNotCopyCtor1AC1ERKS0_(
-    // CHECK: call {{.*}} @_ZN25ElidableCallIsNotCopyCtor1BC1ENS_1AE(
+    // PRE17: call {{.*}} @_ZN25ElidableCallIsNotCopyCtor1AC1ERKS0_(
+    // PRE17: call {{.*}} @_ZN25ElidableCallIsNotCopyCtor1BC1ENS_1AE(
+    // CXX17-NOT: call
+    // CHECK: ret
     B b = 0;
   }
 }

clang/test/CodeGenCXX/debug-info-template-parameter.cpp

 // Test for DebugInfo for Defaulted parameters for C++ templates
 // Supported: -O0, standalone DI
 
-// RUN: %clang_cc1 -dwarf-version=5  -emit-llvm -triple x86_64-linux-gnu %s -o - \
-// RUN:   -O0 -disable-llvm-passes \
-// RUN:   -debug-info-kind=standalone \
-// RUN: | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm %stdcxx_11-14 -dwarf-version=5 -triple x86_64 %s -O0 -disable-llvm-passes -debug-info-kind=standalone -o - | FileCheck %s --check-prefixes=CHECK,PRE17
+// RUN: %clang_cc1 -emit-llvm %stdcxx_17- -dwarf-version=5 -triple x86_64 %s -O0 -disable-llvm-passes -debug-info-kind=standalone -o - | FileCheck %s --check-prefixes=CHECK,CXX17
 
 // CHECK: DILocalVariable(name: "f1", {{.*}}, type: ![[TEMPLATE_TYPE:[0-9]+]]
 // CHECK: [[TEMPLATE_TYPE]] = {{.*}}!DICompositeType({{.*}}, templateParams: ![[F1_TYPE:[0-9]+]]
 // CHECK: [[F1_TYPE]] = !{![[FIRST:[0-9]+]], ![[SECOND:[0-9]+]], ![[THIRD:[0-9]+]], ![[FORTH:[0-9]+]]}
 // CHECK: [[FIRST]] = !DITemplateTypeParameter(name: "T", type: !{{[0-9]*}})
 // CHECK: [[SECOND]] = !DITemplateValueParameter(name: "i", type: !{{[0-9]*}}, value: i32 6)
-// CHECK: [[THIRD]] = !DITemplateValueParameter(name: "b", type: !{{[0-9]*}}, value: i8 0)
+// PRE17: [[THIRD]] = !DITemplateValueParameter(name: "b", type: !{{[0-9]*}}, value: i8 0)
+// CXX17: [[THIRD]] = !DITemplateValueParameter(name: "b", type: !{{[0-9]*}}, value: i1 false)
 
 // CHECK: DILocalVariable(name: "f2", {{.*}}, type: ![[TEMPLATE_TYPE:[0-9]+]]
 // CHECK: [[TEMPLATE_TYPE]] = {{.*}}!DICompositeType({{.*}}, templateParams: ![[F2_TYPE:[0-9]+]]
 // CHECK: [[F2_TYPE]] = !{![[FIRST:[0-9]+]], ![[SECOND:[0-9]+]], ![[THIRD:[0-9]+]], ![[FORTH:[0-9]+]]}
 // CHECK: [[FIRST]] = !DITemplateTypeParameter(name: "T", type: !{{[0-9]*}}, defaulted: true)
 // CHECK: [[SECOND]] = !DITemplateValueParameter(name: "i", type: !{{[0-9]*}}, defaulted: true, value: i32 3)
-// CHECK: [[THIRD]] = !DITemplateValueParameter(name: "b", type: !{{[0-9]*}}, defaulted: true, value: i8 1)
+// PRE17: [[THIRD]] = !DITemplateValueParameter(name: "b", type: !{{[0-9]*}}, defaulted: true, value: i8 1)
+// CXX17: [[THIRD]] = !DITemplateValueParameter(name: "b", type: !{{[0-9]*}}, defaulted: true, value: i1 true)
 
 template <typename T = char, int i = 3, bool b = true, int x = sizeof(T)>
 class foo {
 };
 
 int main() {
   foo<int, 6, false, 3> f1;
   foo<> f2;
   return 0;
 }

clang/test/CodeGenCXX/debug-info-template-partial-specialization.cpp

-// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - -debug-info-kind=standalone | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - -debug-info-kind=standalone %stdcxx_98-14 | FileCheck %s --check-prefixes=CHECK,PRE17
+// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - -debug-info-kind=standalone %stdcxx_17- | FileCheck %s --check-prefixes=CHECK,CXX17
 namespace __pointer_type_imp
 {
   template <class _Tp, class _Dp, bool > struct __pointer_type1 {};
 
   // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "__pointer_type1<C, default_delete<C>, false>",
   // CHECK-SAME:             templateParams: ![[PARAMS:[0-9]+]]
   // CHECK-SAME:             identifier: "_ZTSN18__pointer_type_imp15__pointer_type1I1C14default_deleteIS1_ELb0EEE"
   template <class _Tp, class _Dp> struct __pointer_type1<_Tp, _Dp, false>
   {
     typedef _Tp* type;
   };
 }
 template <class _Tp, class _Dp>
 struct __pointer_type2
 {
   // Test that the bool template type parameter is emitted.
   //
   // CHECK: ![[PARAMS]] = !{!{{.*}}, !{{.*}}, ![[FALSE:[0-9]+]]}
-  // CHECK: ![[FALSE]] = !DITemplateValueParameter(type: !{{[0-9]+}}, value: i8 0)
+  // PRE17: ![[FALSE]] = !DITemplateValueParameter(type: !{{[0-9]+}}, value: i8 0)
+  // CXX17: ![[FALSE]] = !DITemplateValueParameter(type: !{{[0-9]+}}, value: i1 false)
   typedef typename __pointer_type_imp::__pointer_type1<_Tp, _Dp, false>::type type;
 };
 template <class _Tp> struct default_delete {};
 template <class _Tp, class _Dp = default_delete<_Tp> > class unique_ptr
 {
   typedef typename __pointer_type2<_Tp, _Dp>::type pointer;
   unique_ptr(pointer __p, _Dp __d) {}
 };
 class C {
   unique_ptr<C> Ptr;
 };
 void foo(C &c) {
 }

clang/test/CodeGenCXX/exception-spec-decay.cpp

-// RUN: %clang_cc1 -fcxx-exceptions -fexceptions %s -triple=i686-unknown-linux -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 %stdcxx_98- -fcxx-exceptions -fexceptions -Wno-dynamic-exception-spec %s -triple=i686-unknown-linux -emit-llvm -o - | FileCheck %s
 typedef int Array[10];
 
 void foo() throw (Array) {
   throw 0;
   // CHECK: landingpad
   // CHECK-NEXT: filter {{.*}} @_ZTIPi
 }
 

clang/test/CodeGenCXX/exceptions-cxx-ehsc.cpp

-// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 -fexceptions -fcxx-exceptions -fexternc-nounwind | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 -fexceptions -fcxx-exceptions -fexternc-nounwind -Wno-dynamic-exception-spec %stdcxx_98- | FileCheck %s
 
 namespace test1 {
 struct Cleanup { ~Cleanup(); };
 extern "C" void never_throws();
 void may_throw();
 
 void caller() {
   Cleanup x;

clang/test/CodeGenCXX/exceptions-no-rtti.cpp

-// RUN: %clang_cc1 -fno-rtti -fcxx-exceptions -fexceptions %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -fno-rtti -fcxx-exceptions -fexceptions -Wno-dynamic-exception-spec %s -triple=x86_64-apple-darwin10 -emit-llvm -o - %stdcxx_98- | FileCheck %s
 
 // CHECK: @_ZTIN5test11AE = linkonce_odr constant
 // CHECK: @_ZTIN5test11BE = linkonce_odr constant
 // CHECK: @_ZTIN5test11CE = linkonce_odr constant
 // CHECK: @_ZTIN5test11DE = linkonce_odr constant
 // CHECK: @_ZTIPN5test11DE = linkonce_odr constant {{.*}} @_ZTIN5test11DE
 
 // PR6974: this shouldn't crash

clang/test/CodeGenCXX/global-init.cpp

-// RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm -fexceptions %s -o - |FileCheck %s
-// RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm %s -o - |FileCheck -check-prefix CHECK-NOEXC %s
-// RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm -mframe-pointer=non-leaf %s -o - \
+// RUN: %clang_cc1 %stdcxx_98-14 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm -fexceptions %s -o - |FileCheck %s --check-prefixes=CHECK,PRE17
+// RUN: %clang_cc1 %stdcxx_98-14 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm %s -o - |FileCheck %s --check-prefixes=CHECK-NOEXC,PRE17
+// RUN: %clang_cc1 %stdcxx_98-14 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm -mframe-pointer=non-leaf %s -o - \
 // RUN:   | FileCheck -check-prefix CHECK-FP %s
-// RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm %s -o - -fno-builtin \
+// RUN: %clang_cc1 %stdcxx_98-14 -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm %s -o - -fno-builtin \
 // RUN:   | FileCheck -check-prefix CHECK-NOBUILTIN %s
+// RUN: %clang_cc1 %stdcxx_17- -no-opaque-pointers -triple=x86_64-apple-darwin10 -emit-llvm -fexceptions %s -o - | FileCheck %s
 
 struct A {
   A();
   ~A();
 };
 
 struct B { B(); ~B(); };
 
namespace test7 {
   // CHECK: call i32 @__cxa_atexit({{.*}} @_ZN5test71BD1Ev{{.*}} @_ZGRN5test72b2E
   // CHECK: call void @_ZN5test71BD1Ev(
   // CHECK: store {{.*}} @_ZN5test7L2b3E
   const B b1 = B();
   const B &b2 = B();
   const int b3 = B().n;
 
   // CHECK-NOT: @_ZN5test7L2c1E
-  // CHECK: call void @llvm.memset{{.*}} @_ZN5test7L2c1E
+  // PRE17: call void @llvm.memset{{.*}} @_ZN5test7L2c1E
   // CHECK-NOT: @_ZN5test7L2c1E
   // CHECK: @_ZN5test7L2c2E
   // CHECK-NOT: @_ZN5test7L2c3E
-  // CHECK: @_ZN5test7L2c4E
+  // PRE17: @_ZN5test7L2c4E
   const C c1 = C();
   const C c2 = static_cast<const C&>(C());
   const int c3 = C().n;
   const int c4 = C(C()).n;
 
   // CHECK-NOT: @_ZN5test7L1dE
   const D d = D();
 

clang/test/CodeGenCXX/no-exceptions.cpp

-// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 %stdcxx_11- -Wno-dynamic-exception-spec %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
 
 void g();
 
 // CHECK: define{{.*}} void @_Z1fv() [[NUW:#[0-9]+]]
 void f() throw (int) { 
 
   // CHECK-NOT: invoke void @_Z1gv
   g();
   // CHECK: call void @_Z1gv()
   // CHECK: ret void
 }
 
 // CHECK: attributes [[NUW]] = { mustprogress noinline nounwind{{.*}} }

clang/test/CodeGenCXX/override-bit-field-layout.cpp

-// RUN: %clang_cc1 -w -triple=x86_64-pc-win32 -fms-compatibility -fdump-record-layouts-simple -foverride-record-layout=%S/Inputs/override-bit-field-layout.layout %s | FileCheck %s
+// RUN: %clang_cc1 %stdcxx_98-14 -w -triple=x86_64-pc-win32 -fms-compatibility -fdump-record-layouts-simple -foverride-record-layout=%S/Inputs/override-bit-field-layout.layout %s | FileCheck %s --check-prefixes=CHECK,PRE17
+// RUN: %clang_cc1 -std=c++17 -w -triple=x86_64-pc-win32 -fms-compatibility -fdump-record-layouts-simple -foverride-record-layout=%S/Inputs/override-bit-field-layout.layout %s | FileCheck %s --check-prefixes=CHECK,CXX17
+// RUN: %clang_cc1 %stdcxx_20- -w -triple=x86_64-pc-win32 -fms-compatibility -fdump-record-layouts-simple -foverride-record-layout=%S/Inputs/override-bit-field-layout.layout %s | FileCheck %s --check-prefixes=CHECK,CXX20
 
-// CHECK: Type: struct S1
-// CHECK:   FieldOffsets: [0, 11]
+// PRE17: Type: struct S1
+// PRE17:   FieldOffsets: [0, 11]
 struct S1 {
   short a : 3;
   short b : 5;
 };
 
 // CHECK: Type: struct S2
 // CHECK:   FieldOffsets: [64]
 struct S2 {
   virtual ~S2() = default;
   short a : 3;
 };
 
+// CXX17: Type: struct S1
+// CXX17:   FieldOffsets: [0, 11]
+// CXX20: Type: struct S1
+// CXX20:   FieldOffsets: [0, 3]
+
 // CHECK: Type: struct S3
 // CHECK:   Size:32
 // CHECK:   FieldOffsets: [0, 1]
 struct S3 {
   int a : 1;
   int b : 2;
 };
 

clang/test/CodeGenCXX/override-layout.cpp

-// RUN: %clang_cc1 -w -fdump-record-layouts-simple %s > %t.layouts
-// RUN: %clang_cc1 -w -fdump-record-layouts-simple %s > %t.before
-// RUN: %clang_cc1 -w -DPACKED= -DALIGNED16= -fdump-record-layouts-simple -foverride-record-layout=%t.layouts %s > %t.after
+// RUN: %clang_cc1 %stdcxx_98-14 -w -fdump-record-layouts-simple %s > %t.layouts
+// RUN: %clang_cc1 %stdcxx_98-14 -w -fdump-record-layouts-simple %s > %t.before
+// RUN: %clang_cc1 %stdcxx_98-14 -w -DPACKED= -DALIGNED16= -fdump-record-layouts-simple -foverride-record-layout=%t.layouts %s > %t.after
 // RUN: diff -u %t.before %t.after
-// RUN: FileCheck %s < %t.after
+// RUN: FileCheck --check-prefixes=CHECK,PRE17 %s < %t.after
+
+// RUN: %clang_cc1 -std=c++17 -w -fdump-record-layouts-simple %s > %t.layouts
+// RUN: %clang_cc1 -std=c++17 -w -fdump-record-layouts-simple %s > %t.before
+// RUN: %clang_cc1 -std=c++17 -w -DPACKED= -DALIGNED16= -fdump-record-layouts-simple -foverride-record-layout=%t.layouts %s > %t.after
+// RUN: diff -u %t.before %t.after
+// RUN: FileCheck --check-prefixes=CHECK,CXX17 %s < %t.after
+
+// CXX17: Type: struct X6
 
 // If not explicitly disabled, set PACKED to the packed attribute.
 #ifndef PACKED
 #  define PACKED __attribute__((packed))
 #endif
 
 struct Empty1 { };
 struct Empty2 { };
 
struct PACKED X5 {
   union {
     long a;
     long b;
   };
   short l;
   short r;
 };
 
-// CHECK: Type: struct X6
+// PRE17: Type: struct X6
 struct __attribute__((aligned(16))) X6 {
   int x;
   int y;
   virtual ~X6();
 };
 
-// CHECK: Type: struct X7
+// PRE17: Type: struct X7
 struct X7 {
   int z;
 };
 
-// CHECK: Type: struct X8
+// PRE17: Type: struct X8
 struct X8 : X6, virtual X7 {
   char c;
 };
 
 void use_structs() {
   X0 x0s[sizeof(X0)];
   X1 x1s[sizeof(X1)];
   X2 x2s[sizeof(X2)];

clang/test/CodeGenCXX/reference-temporary-ms.cpp

-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple=i386-pc-win32 -fms-extensions | FileCheck %s
+// RUN: %clang_cc1 %stdcxx_98-14 -no-opaque-pointers -emit-llvm %s -o - -triple=i386-pc-win32 -fms-extensions | FileCheck %s --check-prefixes=CHECK,PRE17
+// RUN: %clang_cc1 %stdcxx_17- -no-opaque-pointers -emit-llvm %s -o - -triple=i386-pc-win32 -fms-extensions | FileCheck %s --check-prefixes=CHECK,CXX17
 
 const int __declspec(dllexport) &Exported = 42;
 
 // The reference temporary shouldn't be dllexport, even if the reference is.
-// CHECK: @"?$RT1@Exported@@3ABHB" = internal constant i32 42
+// PRE17: @"?$RT1@Exported@@3ABHB" = internal constant i32 42
+// CXX17: @"?$RT1@Exported@@3ABHB" = internal global i32 42
 
 // CHECK: @"?Exported@@3ABHB" = dso_local dllexport constant i32* @"?$RT1@Exported@@3ABHB"

clang/test/CodeGenCXX/rtti-linkage.cpp

-// RUN: %clang_cc1 -no-opaque-pointers %s -I%S -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-BOTH
-// RUN: %clang_cc1 -no-opaque-pointers %s -I%S -triple=x86_64-apple-darwin10 -fvisibility hidden -emit-llvm -o - | FileCheck -check-prefix=CHECK-WITH-HIDDEN -check-prefix=CHECK-BOTH %s
+// RUN: %clang_cc1 %stdcxx_98- -no-opaque-pointers %s -I%S -triple=x86_64-apple-darwin10 -emit-llvm -Wno-dynamic-exception-spec -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-BOTH
+// RUN: %clang_cc1 %stdcxx_98- -no-opaque-pointers %s -I%S -triple=x86_64-apple-darwin10 -emit-llvm -Wno-dynamic-exception-spec -fvisibility hidden -o - | FileCheck -check-prefix=CHECK-WITH-HIDDEN -check-prefix=CHECK-BOTH %s
 
 #include <typeinfo>
 
 // CHECK-BOTH: _ZTSP1C = internal constant
 // CHECK-BOTH: _ZTS1C = internal constant
 // CHECK-BOTH: _ZTI1C = internal constant
 // CHECK-BOTH: _ZTIP1C = internal constant
 // CHECK-BOTH: _ZTSPP1C = internal constant

clang/test/Layout/ms-x86-vtordisp.cpp

-// RUN: %clang_cc1 -fno-rtti -fms-extensions -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
+// RUN: %clang_cc1 -std=c++14 -fno-rtti -fms-extensions -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
 // RUN:            | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -fms-extensions -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
+// RUN: %clang_cc1 -std=c++14 -fno-rtti -fms-extensions -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
 // RUN:            | FileCheck %s -check-prefix CHECK-X64
 
 extern "C" int printf(const char *fmt, ...);
 
 struct B0 {
   int a;
   B0() : a(0xf00000B0) {}
   virtual void f() { printf("B0"); }

clang/test/Modules/update-exception-spec.cpp

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/update-exception-spec -emit-llvm-only %s
+// RUN: %clang_cc1 %stdcxx_11- -fexceptions -fcxx-exceptions -Wno-dynamic-exception-spec -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I%S/Inputs/update-exception-spec -emit-llvm-only %s
 #include "a.h"
 void use(B *p);
 #include "c.h"
 void use(B *p) { g(p); }

clang/test/OpenMP/declare_mapper_messages.cpp

-// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s
-// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -std=c++98 %s
-// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -std=c++11 %s
-
-// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s
-// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 -std=c++98 %s
-// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 -std=c++11 %s
+// RUN: %clang_cc1 -verify=expected,cxx17 -fopenmp -ferror-limit 100 %stdcxx_17- %s
+// RUN: %clang_cc1 -verify=expected,precxx17 -fopenmp-simd -ferror-limit 100 %stdcxx_98-14 %s
 
 int temp; // expected-note {{'temp' declared here}}
 
 class vec {
 private:
   int p;                                                                // expected-note {{declared private here}}
 public:
   int len;

 public:
   int len;
   T *data;
 #pragma omp declare mapper(id: vec v) map(v.len)                        // expected-note {{previous definition is here}}
 #pragma omp declare mapper(id: vec v) map(v.len)                        // expected-error {{redefinition of user-defined mapper for type 'vec' with name 'id'}}
 };
 };
 
-#pragma omp declare mapper(default : N1::stack s) map(s.len)            // expected-error {{use of class template 'N1::stack' requires template arguments}}
+#pragma omp declare mapper(default : N1::stack s) map(s.len)            // precxx17-error {{use of class template 'N1::stack' requires template arguments}} \
+                                                                           cxx17-error {{use of class template 'stack' requires template arguments; argument deduction not allowed in function prototype}}
 #pragma omp declare mapper(id1: N1::stack<int> s) map(s.data)
 #pragma omp declare mapper(default : S<int> s) map(s.len)               // expected-error {{no template named 'S'}}
 
 template <class T>
 T foo(T a) {
 #pragma omp declare mapper(id: vec v) map(v.len)                        // expected-note {{previous definition is here}}
 #pragma omp declare mapper(id: vec v) map(v.len)                        // expected-error {{redefinition of user-defined mapper for type 'vec' with name 'id'}}
 }

clang/test/PCH/cxx-functions.cpp

 // Test this without pch.
-// RUN: %clang_cc1 -include %S/cxx-functions.h -fsyntax-only -verify %s
+// RUN: %clang_cc1 -include %S/cxx-functions.h -fsyntax-only -verify -Wno-dynamic-exception-spec %stdcxx_98- %s
 
-// RUN: %clang_cc1 -x c++-header -emit-pch -o %t %S/cxx-functions.h
-// RUN: %clang_cc1 -include-pch %t -fsyntax-only -verify %s
+// RUN: %clang_cc1 -x c++-header -Wno-dynamic-exception-spec -emit-pch -o %t %S/cxx-functions.h
+// RUN: %clang_cc1 -include-pch %t -fsyntax-only -verify -Wno-dynamic-exception-spec %s
 
 // expected-no-diagnostics
 
 
 void test_foo() {
   foo();
 }

clang/test/Parser/cxx-casting.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 char *const_cast_test(const char *var)
 {
   return const_cast<char*>(var);
 }
 
 struct A {
   virtual ~A() {}

clang/test/Parser/cxx-class.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fcxx-exceptions %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify -pedantic -fcxx-exceptions %s
 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fcxx-exceptions -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fcxx-exceptions -std=c++11 %s
 
 class C;
 class C {
 public:
 protected:
   typedef int A,B;

clang/test/Parser/cxx-template-argument.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
-// RUN: %clang_cc1 -fsyntax-only -verify %s -fdelayed-template-parsing
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s -fdelayed-template-parsing
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s -fdelayed-template-parsing
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -fdelayed-template-parsing
 
 template<typename T> struct A {};
 
 // Check for template argument lists followed by junk
 // FIXME: The diagnostics here aren't great...
 A<int+> int x; // expected-error {{expected '>'}} expected-note {{to match this '<'}} expected-error {{expected unqualified-id}}

clang/test/Parser/cxx-template-decl.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp14 %s
-// RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp14 %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp14 -std=gnu++14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp14 -std=gnu++14 %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
 // RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp17 -std=gnu++1z %s
 
 
 
 // Errors
 export class foo { };   // expected-error {{expected template}}
 template  x;            // expected-error {{a type specifier is required for all declarations}} \
                         // expected-error {{does not refer}}

clang/test/Parser/cxx1z-nested-namespace-definition.cpp

 // RUN: cp %s %t
 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++98
-// RUN: not %clang_cc1 -x c++ -fixit %t -Werror -DFIXIT
-// RUN: %clang_cc1 -x c++ %t -DFIXIT
+// RUN: not %clang_cc1 -x c++ -std=c++14 -fixit %t -Werror -DFIXIT
+// RUN: %clang_cc1 -x c++ -std=c++14 %t -DFIXIT
 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++17 -Wc++14-compat
 
 namespace foo1::foo2::foo3 {
 #if __cplusplus <= 201400L
 // expected-warning@-2 {{nested namespace definition is a C++17 extension; define each namespace separately}}
 #else
 // expected-warning@-4 {{nested namespace definition is incompatible with C++ standards before C++17}}
 #endif

clang/test/Sema/ms_class_layout.cpp

-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \
+// RUN: %clang_cc1 -std=c++14 -no-opaque-pointers -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \
 // RUN:            | FileCheck %s --strict-whitespace
 
 #pragma pack(push, 8)
 
 class B {
 public:
   virtual void b(){}
   int b_field;

clang/test/SemaCXX/MicrosoftExtensions.cpp

-// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
-// RUN: %clang_cc1 -std=c++98 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
-// RUN: %clang_cc1 -std=c++11 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
-// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fexceptions -fcxx-exceptions -DTEST2
+// RUN: %clang_cc1 -std=c++17 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
+// RUN: %clang_cc1 -std=c++98 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify=expected,precxx17 -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
+// RUN: %clang_cc1 -std=c++11 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify=expected,precxx17 -fms-extensions -fexceptions -fcxx-exceptions -DTEST1
+// RUN: %clang_cc1 -std=c++14 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -Wc++11-extensions -Wno-long-long -verify=expected,precxx17 -fexceptions -fcxx-exceptions -DTEST2
 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -std=c++11 -fms-compatibility -verify -DTEST3
 
 #if TEST1
 
 // MSVC allows type definition in anonymous union and struct
 struct A
 {
   union
__inline void FreeIDListArray(LPITEMIDLIST *ppidls) {
   __unaligned int *x = 0;
   void *y = x;
 }
 
 // Test from PR27666
 // We should accept type conversion of __unaligned to non-__unaligned references
 typedef struct in_addr {
 public:
-  in_addr(in_addr &a) {} // expected-note {{candidate constructor not viable: expects an lvalue for 1st argument}}
-  in_addr(in_addr *a) {} // expected-note {{candidate constructor not viable: no known conversion from 'IN_ADDR' (aka 'in_addr') to 'in_addr *' for 1st argument}}
+  in_addr(in_addr &a) {} // precxx17-note {{candidate constructor not viable: expects an lvalue for 1st argument}}
+  in_addr(in_addr *a) {} // precxx17-note {{candidate constructor not viable: no known conversion from 'IN_ADDR' (aka 'in_addr') to 'in_addr *' for 1st argument}}
 } IN_ADDR;
 
 void f(IN_ADDR __unaligned *a) {
   IN_ADDR local_addr = *a;
   // FIXME: MSVC accepts the following; not sure why clang tries to
   // copy-construct an in_addr.
-  IN_ADDR local_addr2 = a; // expected-error {{no viable constructor copying variable of type 'IN_ADDR' (aka 'in_addr')}}
+  IN_ADDR local_addr2 = a; // precxx17-error {{no viable constructor copying variable of type 'IN_ADDR' (aka 'in_addr')}}
   // expected-warning@-1 {{implicit cast from type '__unaligned IN_ADDR *' (aka '__unaligned in_addr *') to type 'in_addr *' drops __unaligned qualifier}}
   IN_ADDR local_addr3(a);
   // expected-warning@-1 {{implicit cast from type '__unaligned IN_ADDR *' (aka '__unaligned in_addr *') to type 'in_addr *' drops __unaligned qualifier}}
 }
 
 template<typename T> void h1(T (__stdcall M::* const )()) { }
 
 void m1() {

clang/test/SemaCXX/PR12778.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wno-dynamic-exception-spec -verify %s
 
 void operator delete() throw(void*); // expected-error{{'operator delete' must have at least one parameter}}
 void* allocate(int __n) {
    return ::operator new(__n);
 }
 

clang/test/SemaCXX/altivec.cpp

-// RUN: %clang_cc1 -target-feature +altivec -flax-vector-conversions=none -triple powerpc-unknown-unknown -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -target-feature +altivec -flax-vector-conversions=none -triple powerpc-unknown-unknown -fcxx-exceptions -verify=expected,precxx17 %stdcxx_98-14 %s
+// RUN: %clang_cc1 -target-feature +altivec -flax-vector-conversions=none -triple powerpc-unknown-unknown -fcxx-exceptions -verify %stdcxx_17- %s
 
 typedef int V4i __attribute__((vector_size(16)));
 
 void test_vec_step(vector short arg1) {
   vector bool char vbc;
   vector signed char vsc;
   vector unsigned char vuc;
   vector bool short vbs;
void test2()
   vector int vi;
   ++vi;
   vi++;
   --vi;
   vi--;
   vector float vf;
   vf++;
 
-  ++vi=vi; // expected-warning {{unsequenced}}
+  ++vi=vi; // precxx17-warning {{unsequenced}}
   (++vi)[1]=1;
   template_f(vi);
 }
 
 namespace LValueToRValueConversions {
   struct Struct {
     float f();
     int n();

clang/test/SemaCXX/bool.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -Wno-constant-conversion %s
-// RUN: %clang_cc1 -fsyntax-only -verify -Wno-constant-conversion \
-// RUN:     -Wno-deprecated -Wdeprecated-increment-bool %s
+// RUN: %clang_cc1 %stdcxx_98-14 -fsyntax-only -verify=expected,precxx17 -Wno-constant-conversion %s
+// RUN: %clang_cc1 %stdcxx_98-14 -fsyntax-only -verify=expected,precxx17 -Wno-constant-conversion -Wno-deprecated -Wdeprecated-increment-bool %s
+// RUN: %clang_cc1 %stdcxx_17- -fsyntax-only -verify=expected,cxx17 -Wno-constant-conversion -Wno-deprecated -Wdeprecated-increment-bool %s
 
 // Bool literals can be enum values.
 enum {
   ReadWrite = false,
   ReadOnly = true
 };
 
 // bool cannot be decremented, and gives a warning on increment
 void test(bool b)
 {
-  ++b; // expected-warning {{incrementing expression of type bool is deprecated}}
-  b++; // expected-warning {{incrementing expression of type bool is deprecated}}
+  ++b; // precxx17-warning {{incrementing expression of type bool is deprecated}} \
+          cxx17-error {{ISO C++17 does not allow incrementing expression of type bool}}
+  b++; // precxx17-warning {{incrementing expression of type bool is deprecated}} \
+          cxx17-error {{ISO C++17 does not allow incrementing expression of type bool}}
   --b; // expected-error {{cannot decrement expression of type bool}}
   b--; // expected-error {{cannot decrement expression of type bool}}
 
   bool *b1 = (int *)0; // expected-error{{cannot initialize}}
 }
 
 // static_assert_arg_is_bool(x) compiles only if x is a bool.
 template <typename T>

clang/test/SemaCXX/default2.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 %stdcxx_11-14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx17 %stdcxx_17- %s
 
 void f(int i, int j, int k = 3);
 void f(int i, int j, int k);
 void f(int i, int j = 2, int k);
 void f(int i, int j, int k);
 void f(int i = 1, int j, int k);
 void f(int i, int j, int k);
 

 
 void test_Z(const Z& z) {
   Z z2(z); // expected-error{{no matching constructor for initialization of 'Z'}}
 }
 
 struct ZZ {
   static ZZ g(int = 17);
 
-  void f(ZZ z = g()); // expected-error{{no matching constructor for initialization}} \
-  // expected-note{{passing argument to parameter 'z' here}}
+  void f(ZZ z = g()); // precxx17-error{{no matching constructor for initialization}} \
+  // precxx17-note{{passing argument to parameter 'z' here}}
 
-  ZZ(ZZ&, int = 17); // expected-note{{candidate constructor}}
+  ZZ(ZZ&, int = 17); // precxx17-note{{candidate constructor}}
 };
 
 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#325
 class C2 {
   static void g(int = f()); // expected-error{{use of default argument to function 'f' that is declared later in class 'C2'}}
   static int f(int = 10); // expected-note{{default argument declared here}}
 };
 

clang/test/SemaCXX/exception-spec-no-exceptions.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fobjc-exceptions %s
+// RUN: %clang_cc1 %stdcxx_98-14 -fsyntax-only -verify -fexceptions -fobjc-exceptions %s
 // expected-no-diagnostics
 
 // Note that we're specifically excluding -fcxx-exceptions in the command line above.
 
 // That this should work even with -fobjc-exceptions is PR9358
 
 // PR7243: redeclarations
 namespace test0 {

clang/test/SemaCXX/exceptions.cpp

-// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
-// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
-// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify=expected,precxx17 %stdcxx_98-14 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %stdcxx_17- %s
 
 struct A; // expected-note 4 {{forward declaration of 'A'}}
 
 struct Abstract { virtual void f() = 0; }; // expected-note {{unimplemented pure virtual method 'f'}}
 
 void trys() {
   int k = 42;
   try {
void f() {
     using namespace NA;
     using namespace NB;
     try {
     } catch (int S) { 
     }
   }
 }
 
+#if __cplusplus < 201703L
 namespace Decay {
   struct A {
     void f() throw (A[10]);
   };
 
   template<typename T> struct B {
     void f() throw (B[10]);
   };
#if __cplusplus <= 199711L
   // expected-note@-2 {{in instantiation of template class 'Decay::C<Decay::E[10]>' requested here}}
 #endif
 }
 
 void rval_ref() throw (int &&); // expected-error {{rvalue reference type 'int &&' is not allowed in exception specification}}
 #if __cplusplus <= 199711L
 // expected-warning@-2 {{rvalue references are a C++11 extension}}
 #endif
+#endif
 
 namespace HandlerInversion {
 struct B {};
 struct D : B {};
 struct D2 : D {};
 
 void f1() {
   try {
void f8() {
   } catch (B b) { // expected-note {{for type 'B'}}
   } catch (D &d) { // expected-warning {{exception of type 'D &' will be caught by earlier handler}}
   }
 }
 }
 
 namespace ConstVolatileThrow {
 struct S {
-  S() {}         // expected-note{{candidate constructor not viable}}
-  S(const S &s); // expected-note{{candidate constructor not viable}}
+  S() {}         // precxx17-note{{candidate constructor not viable}}
+  S(const S &s); // precxx17-note{{candidate constructor not viable}}
 };
 
 typedef const volatile S CVS;
 
 void f() {
-  throw CVS(); // expected-error{{no matching constructor for initialization}}
+  throw CVS(); // precxx17-error{{no matching constructor for initialization}}
 }
 }
 
 namespace ConstVolatileCatch {
 struct S {
   S() {}
   S(const volatile S &s);
 

clang/test/SemaCXX/expressions.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-constant-conversion %s
 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-constant-conversion -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-constant-conversion -std=c++11 %s
 
 void choice(int);
 int choice(bool);
 
 void test() {
   // Result of ! must be type bool.
   int i = choice(!1);
 }
 
+#if __cplusplus < 201703L
 // rdar://8018252
 void f0() {
   extern void f0_1(int*);
   register int x;
 #if __cplusplus >= 201103L // C++11 or later
   // expected-warning@-2 {{'register' storage class specifier is deprecated}}
 #endif
   f0_1(&x);
 }
+#endif
 
 namespace test1 {
   template <class T> void bar(T &x) { T::fail(); }
   template <class T> void bar(volatile T &x) {}
 
   void test_ints() {
     volatile int x;
     bar(x = 5);

clang/test/SemaCXX/inline.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++17 %s -Wpre-c++17-compat
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx17-compat -std=c++17 %s -Wpre-c++17-compat
 
 // Check that we don't allow illegal uses of inline
 // (checking C++-only constructs here)
 struct c {inline int a;}; // expected-error{{'inline' can only appear on functions}}
 
 void localVar() {
   inline int a; // expected-error{{inline declaration of 'a' not allowed in block scope}}
 }
 
 // Check that we warn appropriately.
 #if __cplusplus <= 201402L
 inline int a; // expected-warning{{inline variables are a C++17 extension}}
 #else
-inline int a; // expected-warning{{inline variables are incompatible with C++ standards before C++17}}
+inline int a; // cxx17-compat-warning{{inline variables are incompatible with C++ standards before C++17}}
 #endif

clang/test/SemaCXX/libstdcxx_is_pod_hack.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify %stdcxx_98-14 %s
 
 // This is a test for an egregious hack in Clang that works around
 // issues with GCC's evolution. libstdc++ 4.2.x uses __is_pod as an
 // identifier (to declare a struct template like the one below), while
 // GCC 4.3 and newer make __is_pod a keyword. Clang treats __is_pod as
 // a keyword *unless* it is introduced following the struct keyword.
 
 template<typename T>

clang/test/SemaCXX/linkage2.cpp

 }
 
 namespace test17 {
   namespace {
     struct I {
     };
   }
   template <typename T1, typename T2> void foo() {}
-  template <typename T, T x> void bar() {} // expected-note {{candidate function}}
+  template <typename T, T x> void bar() {}
+#if __cplusplus < 201703L
+  // expected-note@-2 {{candidate function}}
+#endif
   inline void *g() {
     struct L {
     };
     // foo<L, I>'s linkage should be the merge of UniqueExternalLinkage (or
     // InternalLinkage in c++11) and VisibleNoLinkage. The correct answer is
     // NoLinkage in both cases. This means that using foo<L, I> as a template
     // argument should fail.
-    return reinterpret_cast<void*>(bar<typeof(foo<L, I>), foo<L, I> >); // expected-error {{reinterpret_cast cannot resolve overloaded function 'bar' to type 'void *}}
+    return reinterpret_cast<void*>(bar<typeof(foo<L, I>), foo<L, I> >);
+#if __cplusplus < 201703L
+    // expected-error@-2 {{reinterpret_cast cannot resolve overloaded function 'bar' to type 'void *}}
+#endif
   }
   void h() {
     g();
   }
 }
 
 namespace test18 {
   template <typename T> struct foo {

clang/test/SemaCXX/member-pointer.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify %stdcxx_98- %s
 
 struct A {};
 enum B { Dummy };
 namespace C {}
 struct D : A {};
 struct E : A {};
 struct F : D, E {};
 struct G : virtual D {};
 class H : A {}; // expected-note 2{{implicitly declared private here}}
 
 int A::*pdi1;
 int (::A::*pdi2);
 int (A::*pfi)(int);
-void (*A::*ppfie)() throw(); // expected-error {{exception specifications are not allowed beyond a single level of indirection}}
+void (*A::*ppfie)() throw();
+#if __cplusplus < 201703L
+// expected-error@-2 {{exception specifications are not allowed beyond a single level of indirection}}
+#endif
 
 int B::*pbi;
 #if __cplusplus <= 199711L // C++03 or earlier modes
 // expected-warning@-2 {{use of enumeration in a nested name specifier is a C++11 extension}}
 #endif
 // expected-error@-4 {{'pbi' does not point into a class}}
 int C::*pci; // expected-error {{'pci' does not point into a class}}
 void A::*pdv; // expected-error {{'pdv' declared as a member pointer to void}}

clang/test/SemaCXX/missing-namespace-qualifier-typo-corrections.cpp

namespace realstd {
   class linkedlist { /* ... */ };
 }
 
 void f() {
   mylinkedlist v; // expected-error{{unknown type name 'mylinkedlist'; did you mean 'realstd::mylinkedlist'?}}
   nylinkedlist w; // expected-error{{unknown type name 'nylinkedlist'; did you mean 'realstd::mylinkedlist'?}}
 }
 
+#if __cplusplus < 201703L
 // Test case from http://llvm.org/bugs/show_bug.cgi?id=10318
 namespace llvm {
  template <typename T> class GraphWriter {}; // expected-note 3{{declared here}}
 }
 
 struct S {};
 void bar() {
  GraphWriter<S> x; //expected-error{{no template named 'GraphWriter'; did you mean 'llvm::GraphWriter'?}}
  (void)new llvm::GraphWriter; // expected-error {{use of class template 'llvm::GraphWriter' requires template arguments}}
  (void)new llvm::Graphwriter<S>; // expected-error {{no template named 'Graphwriter' in namespace 'llvm'; did you mean 'GraphWriter'?}}
 }
+#endif
 
 // If namespace prefixes and character edits have the same weight, correcting
 // "fimish" to "N::famish" would have the same edit distance as correcting
 // "fimish" to "Finish". The result would be no correction being suggested
 // unless one of the corrections is given precedence (e.g. by filtering out
 // suggestions with added namespace qualifiers).
 namespace N { void famish(int); }
 void Finish(int); // expected-note {{'Finish' declared here}}

clang/test/SemaCXX/static-data-member.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -w %s
+// RUN: %clang_cc1 %stdcxx_98- -fsyntax-only -verify -w %s
 
 struct ABC {
   static double a;
   static double b;
   static double c;
   static double d;
   static double e;
   static double f;
 };
 
 double ABC::a = 1.0;
 extern double ABC::b = 1.0; // expected-error {{static data member definition cannot specify a storage class}}
 static double ABC::c = 1.0;  // expected-error {{'static' can only be specified inside the class definition}}
 __private_extern__ double ABC::d = 1.0; // expected-error {{static data member definition cannot specify a storage class}}
 auto double ABC::e = 1.0; // expected-error {{static data member definition cannot specify a storage class}}
+#if __cplusplus < 201703L
 register double ABC::f = 1.0; // expected-error {{static data member definition cannot specify a storage class}}
+#endif

clang/test/SemaCXX/type-definition-in-specifier.cpp

-// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -Wno-dynamic-exception-spec -verify %stdcxx_98- %s
 
 struct S0;
 struct S1;
 struct S2;
 struct S3;
 struct S4;
 struct S5;
 struct S6;

clang/test/SemaCXX/user-defined-conversions.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s 
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 %stdcxx_98-14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected %stdcxx_17- %s
 struct X {
   operator bool();
 };
 
 int& f(bool);
 float& f(int);
 
 void f_test(X x) {
void test_conversion(ConvertibleToBase ctb, ConvertibleToDerived ctd,
   Base b1 = ctb;
   Base b2(ctb);
   Base b3 = ctd;
   Base b4(ctd);
   Base b5 = ctfd;
 }
 
 struct X1 {
-  X1(X1&); // expected-note{{candidate constructor not viable: expects an lvalue for 1st argument}}
+  X1(X1&); // precxx17-note{{candidate constructor not viable: expects an lvalue for 1st argument}}
 };
 
 struct X2 {
   operator X1();
 };
 
 int &f(X1);
 float &f(...);
 
 void g(X2 b) {
-  int &ir = f(b); // expected-error{{no viable constructor copying parameter of type 'X1'}}
+  int &ir = f(b); // precxx17-error{{no viable constructor copying parameter of type 'X1'}}
 }
 
 namespace rdar10202900 {
   class A {
   public:
     A();
 
   private:
     A(int i); // expected-note{{declared private here}}
   };
 
   void testA(A a) {
     int b = 10;
     a = b; // expected-error{{calling a private constructor of class 'rdar10202900::A'}}
   }
 }

clang/test/SemaCXX/warn-new-overaligned-3.cpp

-// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned %s -isystem %S/Inputs -verify
+// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned %s -isystem %S/Inputs -verify=precxx17 %stdcxx_11-14
+// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned %s -isystem %S/Inputs -verify %stdcxx_17-
+
+// expected-no-diagnostics
 
 // This test ensures that we still get the warning even if we #include <new>
 // where the header here simulates <new>.
 #include <warn-new-overaligned-3.h>
 
 namespace test1 {
 struct Test {
   template <typename T>
   struct SeparateCacheLines {
     T data;
   } __attribute__((aligned(256)));
 
   SeparateCacheLines<int> high_contention_data[10];
 };
 
 void helper() {
   Test t;
-  new Test;  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
-  new Test[10];  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test;  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test[10];  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
 }
 }
 
 namespace test2 {
 struct helper { int i __attribute__((aligned(256))); };
 
 struct Placement {
   Placement() {
     new (d) helper();
   }
   helper *d;
 };
 }

clang/test/SemaCXX/warn-new-overaligned.cpp

-// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned -verify %s
+// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned -verify=precxx17 %stdcxx_98-14 %s
+// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned -verify=cxx17 %stdcxx_17- %s
 
 namespace test1 {
 struct Test {
   template <typename T>
   struct SeparateCacheLines {
     T data;
   } __attribute__((aligned(256)));
 
   SeparateCacheLines<int> high_contention_data[10];
 };
 
 void helper() {
   Test t;
-  new Test;  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
-  new Test[10];  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test;  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test[10];  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
 }
 }
 
 namespace test2 {
 class Test {
   typedef int __attribute__((aligned(256))) aligned_int;
   aligned_int high_contention_data[10];
 };
 
 void helper() {
   Test t;
-  new Test;  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
-  new Test[10];  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test;  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test[10];  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
 }
 }
 
 namespace test3 {
 struct Test {
   template <typename T>
   struct SeparateCacheLines {
     T data;
   } __attribute__((aligned(256)));
 
   void* operator new(unsigned long) {
-    return 0; // expected-warning {{'operator new' should not return a null pointer unless it is declared 'throw()'}}
+    return 0; // precxx17-warning {{'operator new' should not return a null pointer unless it is declared 'throw()'}} \
+                 cxx17-warning {{'operator new' should not return a null pointer unless it is declared 'throw()' or 'noexcept'}}
   }
 
   SeparateCacheLines<int> high_contention_data[10];
 };
 
 void helper() {
   Test t;
   new Test;
-  new Test[10];  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test[10];  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
 }
 }
 
 namespace test4 {
 struct Test {
   template <typename T>
   struct SeparateCacheLines {
     T data;
   } __attribute__((aligned(256)));
 
   void* operator new[](unsigned long) {
-    return 0; // expected-warning {{'operator new[]' should not return a null pointer unless it is declared 'throw()'}}
+    return 0; // precxx17-warning {{'operator new[]' should not return a null pointer unless it is declared 'throw()'}} \
+                 cxx17-warning {{'operator new[]' should not return a null pointer unless it is declared 'throw()' or 'noexcept'}}
   }
 
   SeparateCacheLines<int> high_contention_data[10];
 };
 
 void helper() {
   Test t;
-  new Test;  // expected-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
+  new Test;  // precxx17-warning {{type 'Test' requires 256 bytes of alignment and the default allocator only guarantees}}
   new Test[10];
 }
 }

clang/test/SemaCXX/writable-strings-deprecated.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s -DWARNING
+// RUN: %clang_cc1 -fsyntax-only -verify %stdcxx_14- %s -DWARNING
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify %s -DWARNING
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wno-deprecated-writable-strings -verify %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wno-deprecated -Wdeprecated-increment-bool -verify %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -fwritable-strings -verify %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wno-write-strings -verify %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Werror=c++11-compat -verify %s -DERROR
 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Werror=deprecated -Wno-error=deprecated-increment-bool -verify %s -DERROR
 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s -DWARNING

 #if __cplusplus >= 201103L
    // expected-warning@-9 {{ISO C++11 does not allow conversion from string literal to 'char *'}}
 #else
    // expected-warning@-11 {{conversion from string literal to 'char *' is deprecated}}
 #endif
 #endif
 }
 
+#if __cplusplus < 201703L
 void test(bool b)
 {
   ++b; // expected-warning {{incrementing expression of type bool is deprecated}}
 }
+#endif

clang/test/SemaSYCL/zero-length-arrays.cpp

-// RUN: %clang_cc1 -fsycl-is-device -triple spir64 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsycl-is-device -triple spir64 -fsyntax-only -verify -std=c++14 %s
 //
 // This test checks if compiler reports compilation error on an attempt to use
 // a zero-length array inside device code.
 
 template <typename Name, typename Func>
 __attribute__((sycl_kernel)) void kernel(const Func &kernelFunc) {
   // expected-note@+1 5{{called by 'kernel}}
   kernelFunc(); // #KernelObjCall

clang/test/SemaTemplate/class-template-id.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx23,precxx17 %stdcxx_98-14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx23,cxx17 %stdcxx_17-20 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx17,cxx23 %stdcxx_23- %s
 template<typename T, typename U = float> struct A { };
 
 typedef A<int> A_int;
 
 typedef float FLOAT;
 
 A<int, FLOAT> *foo(A<int> *ptr, A<int> const *ptr2, A<int, double> *ptr3) {
   if (ptr)
     return ptr; // okay
   else if (ptr2)
-    return ptr2; // expected-error{{cannot initialize return object of type 'A<int, FLOAT> *' (aka 'A<int, float> *') with an lvalue of type 'const A<int> *'}}
+    return ptr2; // precxx23-error{{cannot initialize return object of type 'A<int, FLOAT> *' (aka 'A<int, float> *') with an lvalue of type 'const A<int> *'}} \
+                    cxx23-error{{cannot initialize return object of type 'A<int, FLOAT> *' (aka 'A<int, float> *') with an rvalue of type 'const A<int> *'}}
   else {
-    return ptr3; // expected-error{{cannot initialize return object of type 'A<int, FLOAT> *' (aka 'A<int, float> *') with an lvalue of type 'A<int, double> *'}}
+    return ptr3; // precxx23-error{{cannot initialize return object of type 'A<int, FLOAT> *' (aka 'A<int, float> *') with an lvalue of type 'A<int, double> *'}} \
+                    cxx23-error{{cannot initialize return object of type 'A<int, FLOAT> *' (aka 'A<int, float> *') with an rvalue of type 'A<int, double> *'}}
   }
 }
 
 template<int I> struct B;
 
 const int value = 12;
 B<17 + 2> *bar(B<(19)> *ptr1, B< (::value + 7) > *ptr2, B<19 - 3> *ptr3) {
   if (ptr1)
     return ptr1;
   else if (ptr2)
     return ptr2;
   else
-    return ptr3; // expected-error{{cannot initialize return object of type 'B<17 + 2> *' with an lvalue of type 'B<19 - 3>}}
+    return ptr3; // precxx23-error{{cannot initialize return object of type 'B<17 + 2> *' with an lvalue of type 'B<19 - 3>}} \
+                    cxx23-error{{cannot initialize return object of type 'B<17 + 2> *' with an rvalue of type 'B<19 - 3>}}
 }
 
 typedef B<5> B5;
 
 
 namespace N {
   template<typename T> struct C {};
 }
 
 N::C<int> c1;
 typedef N::C<float> c2;
 
 // PR5655
-template<typename T> struct Foo { }; // expected-note{{template is declared here}}
+template<typename T> struct Foo { }; // precxx17-note {{template is declared here}} \
+                                        cxx17-note {{candidate template ignored: couldn't infer template argument 'T'}} \
+                                        cxx17-note {{candidate function template not viable: requires 1 argument, but 0 were provided}}
 
-void f(void) { Foo bar; } // expected-error{{use of class template 'Foo' requires template arguments}}
+void f(void) { Foo bar; } // precxx17-error {{use of class template 'Foo' requires template arguments}} \
+                             cxx17-error {{no viable constructor or deduction guide for deduction of template arguments of 'Foo'}}
 
 // rdar://problem/8254267
 template <typename T> class Party;
 template <> class Party<T> { friend struct Party<>; }; // expected-error {{use of undeclared identifier 'T'}}

clang/test/SemaTemplate/constructor-template.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 %stdcxx_98-14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++17 %s
 
 struct X0 { // expected-note {{candidate constructor (the implicit copy constructor) not viable}}
 #if __cplusplus >= 201103L // C++11 or later
 // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}}
 #endif
   X0(int); // expected-note{{candidate}}
   template<typename T> X0(T); // expected-note {{candidate}}
   template<typename T, typename U> X0(T*, U*); // expected-note {{candidate}}

 }
 
 // PR4655
 template<class C> struct A {};
 template <> struct A<int>{A(const A<int>&);};
 struct B { A<int> x; B(B& a) : x(a.x) {} };
 
 struct X2 {
-  X2(); // expected-note{{candidate constructor}}
-  X2(X2&);  // expected-note {{candidate constructor}}
-  template<typename T> X2(T); // expected-note {{candidate template ignored: instantiation would take its own class type by value}}
+  X2(); // precxx17-note{{candidate constructor}}
+  X2(X2&);  // precxx17-note {{candidate constructor}}
+  template<typename T> X2(T); // precxx17-note {{candidate template ignored: instantiation would take its own class type by value}}
 };
 
 X2 test(bool Cond, X2 x2) {
   if (Cond)
     return x2; // okay, uses copy constructor
   
-  return X2(); // expected-error{{no matching constructor}}
+  return X2(); // precxx17-error{{no matching constructor}}
 }
 
 struct X3 {
   template<typename T> X3(T);
 };
 
 template<> X3::X3(X3); // expected-error{{must pass its first argument by reference}}
 
namespace self_by_value {
   }
   void test2() {
     helper(A<int,int>());
   }
 }
 
 namespace self_by_value_2 {
   template <class T, class U> struct A {
-    A() {} // expected-note {{not viable: requires 0 arguments}}
-    A(A<T,U> &o) {} // expected-note {{not viable: expects an lvalue}}
-    A(A<T,T> o) {} // expected-note {{ignored: instantiation takes its own class type by value}}
+    A() {} // precxx17-note {{not viable: requires 0 arguments}}
+    A(A<T,U> &o) {} // precxx17-note {{not viable: expects an lvalue}}
+    A(A<T,T> o) {} // precxx17-note {{ignored: instantiation takes its own class type by value}}
   };
 
-  void helper_A(A<int,int>); // expected-note {{passing argument to parameter here}}
+  void helper_A(A<int,int>); // precxx17-note {{passing argument to parameter here}}
   void test_A() {
-    helper_A(A<int,int>()); // expected-error {{no matching constructor}}
+    helper_A(A<int,int>()); // precxx17-error {{no matching constructor}}
   }
 }
 
 namespace self_by_value_3 {
   template <class T, class U> struct A {
     A() {}
     A(A<T,U> &o) {}
     A(A<T,T> o) {}
   };
 
   void helper_A(A<int,int>);
   void test_A(A<int,int> b) {
     helper_A(b);
   }
 }

clang/test/SemaTemplate/explicit-instantiation.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fcxx-exceptions %s
-// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fcxx-exceptions -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fcxx-exceptions -Wno-dynamic-exception-spec %stdcxx_11- %s
 
 template void *; // expected-error{{expected unqualified-id}}
 
 template typedef void f0; // expected-error{{explicit instantiation of typedef}}
 
 int v0; // expected-note{{refers here}}
 template int v0; // expected-error{{does not refer}}
 

clang/test/SemaTemplate/instantiate-exception-spec.cpp

-// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -verify %s -DERRORS
-// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -emit-llvm-only %s
+// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -verify %stdcxx_98-14 %s -DERRORS
+// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -emit-llvm-only %stdcxx_98-14 %s
 
 #ifdef ERRORS
 template<typename T> void f1(T*) throw(T); // expected-error{{incomplete type 'Incomplete' is not allowed in exception specification}}
 struct Incomplete; // expected-note{{forward}}
 
 void test_f1(Incomplete *incomplete_p, int *int_p) {
   f1(int_p);
   f1(incomplete_p); // expected-note{{instantiation of}}

clang/test/SemaTemplate/instantiate-non-dependent-types.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 %stdcxx_98-14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify %stdcxx_17- %s
 template<typename T>
 struct X1 {
-  static void member() { T* x = 1; } // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
+  static void member() { T* x = 1; } // precxx17-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
 };
 
 template<void(*)()> struct instantiate { };
 
 template<typename T>
 struct X2 {
-  typedef instantiate<&X1<int>::member> i; // expected-note{{in instantiation of}}
+  typedef instantiate<&X1<int>::member> i; // precxx17-note{{in instantiation of}}
 };
 
 X2<int> x;
 
 template <class T, class A> class C {
 public:
   int i;
   void f(T &t) {

clang/test/SemaTemplate/instantiation-default-2.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 %stdcxx_98-14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx17 %stdcxx_17- %s
 
-template<typename T, T Value> struct Constant; // expected-note{{template parameter is declared here}} \
-// FIXME: bad location expected-error{{a non-type template parameter cannot have type 'float'}}
+template<typename T, T Value> struct Constant; // precxx17-note{{template parameter is declared here}} \
+// FIXME: bad location precxx17-error{{a non-type template parameter cannot have type 'float'}}
 
 Constant<int, 5> *c1;
 
 int x;
 float f(int, double);
 
 Constant<int&, x> *c2;
 Constant<int*, &x> *c3;
 Constant<float (*)(int, double), f> *c4;
 Constant<float (*)(int, double), &f> *c5;
 
-Constant<float (*)(int, int), f> *c6; // expected-error{{non-type template argument of type 'float (int, double)' cannot be converted to a value of type 'float (*)(int, int)'}}
+Constant<float (*)(int, int), f> *c6; // precxx17-error {{non-type template argument of type 'float (int, double)' cannot be converted to a value of type 'float (*)(int, int)'}} \
+                                         cxx17-error {{value of type 'float (int, double)' is not implicitly convertible to 'float (*)(int, int)'}}
 
-Constant<float, 0> *c7; // expected-note{{while substituting}}
+Constant<float, 0> *c7; // precxx17-note {{while substituting}} \
+                           cxx17-error {{conversion from 'int' to 'float' is not allowed in a converted constant expression}}

clang/test/SemaTemplate/temp_arg.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 %stdcxx_98-14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx17 %stdcxx_17- %s
 template<typename T, 
          int I, 
          template<typename> class TT>
-  class A; // expected-note 3 {{template is declared here}}
+  class A; // precxx17-note 3 {{template is declared here}} \
+              cxx17-note 2 {{template is declared here}} \
+              cxx17-note {{candidate template ignored: couldn't infer template argument 'T'}} \
+              cxx17-note {{candidate function template not viable: requires 1 argument, but 0 were provided}}
 
 template<typename> class X;
 
 A<int, 0, X> * a1;
 
 A<float, 1, X, double> *a2; // expected-error{{too many template arguments for class template 'A'}}
 A<float, 1> *a3; // expected-error{{too few template arguments for class template 'A'}}
-A a4; // expected-error{{use of class template 'A' requires template arguments}}
+A a4; // precxx17-error{{use of class template 'A' requires template arguments}} \
+         cxx17-error{{no viable constructor or deduction guide for deduction of template arguments of 'A'}}
 
 namespace test0 {
   template <class t> class foo {};
   template <class t> class bar {
     bar(::test0::foo<tee> *ptr) {} // expected-error {{use of undeclared identifier 'tee'}}
   };
 }

clang/test/SemaTemplate/temp_arg_template.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 %stdcxx_98-14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx17 -std=c++17 %s
 
 template<template<typename T> class X> struct A; // expected-note 2{{previous template template parameter is here}}
 
 template<template<typename T, int I> class X> struct B; // expected-note{{previous template template parameter is here}}
 
 template<template<int I> class X> struct C;  // expected-note 2{{previous non-type template parameter with type 'int' is here}}
 
 template<class> struct X; // expected-note{{too few template parameters in template template argument}}

 // Evil digraph '<:' is parsed as '[', expect error.
 A<::N::Z> *a10;
 #if __cplusplus <= 199711L
 // expected-error@-2 {{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
 #endif
 
 // Do not do a digraph correction here.
 A<: :N::Z> *a11;  // expected-error{{expected expression}} \
-                     expected-error{{a type specifier is required for all declarations}}
+                     precxx17-error{{a type specifier is required for all declarations}} \
+                     cxx17-error{{expected unqualified-id}}
 
 // PR7807
 namespace N {
   template <typename, typename = int>
   struct X
   { };
 
   template <typename ,int>

 
 void foo() {
   f7<identity>();
 }
 
 namespace CheckDependentNonTypeParamTypes {
   template<template<typename T, typename U, T v> class X> struct A {
     void f() {
-      X<int, void*, 3> x; // expected-error {{does not refer to any declaration}}
+      X<int, void*, 3> x; // precxx17-error {{does not refer to any declaration}} \
+                             cxx17-error {{value of type 'int' is not implicitly convertible to 'void *'}}
     }
     void g() {
       X<int, long, 3> x;
     }
     void h() {
       // FIXME: If we accept A<B> at all, it's not obvious what should happen
       // here. While parsing the template, we form
       //   X<unsigned char, int, (unsigned char)1234>
       // but in the final instantiation do we get
       //   B<unsigned char, int, (int)1234>
       // or
       //   B<unsigned char, int, (int)(unsigned char)1234>
       // ?
       X<unsigned char, int, 1234> x;
       int check[x.value == 1234 ? 1 : -1];
     }
   };
 
-  template<typename T, typename U, U v> struct B { // expected-note {{parameter}}
+  template<typename T, typename U, U v> struct B { // precxx17-note {{parameter}}
     static const U value = v;
   };
 
   // FIXME: This should probably be rejected, but the rules are at best unclear.
   A<B> ab;
 
   void use() {
     ab.f(); // expected-note {{instantiation of}}

clang/test/SemaTemplate/typename-specifier-3.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,precxx17 %stdcxx_11-14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx17 %stdcxx_17- %s
 
 // PR4364
-template<class T> struct a { // expected-note {{here}}
+template<class T> struct a { // precxx17-note {{here}}
   T b() {
     return typename T::x();
   }
 };
 struct B {
   typedef B x;
 };
 B c() {
   a<B> x;
   return x.b();
 }
 
 // Some extra tests for invalid cases
 template<class T> struct test2 { T b() { return typename T::a; } }; // expected-error{{expected '(' for function-style cast or type construction}}
-template<class T> struct test3 { T b() { return typename a; } }; // expected-error{{expected a qualified name after 'typename'}}
-template<class T> struct test4 { T b() { return typename ::a; } }; // expected-error{{refers to non-type member}} expected-error{{expected '(' for function-style cast or type construction}}
+template<class T> struct test3 { T b() { return typename a; } }; // expected-error{{expected a qualified name after 'typename'}} cxx17-error{{expected '(' for function-style cast or type construction}}
+template<class T> struct test4 { T b() { return typename ::a; } }; // precxx17-error{{refers to non-type member}} expected-error{{expected '(' for function-style cast or type construction}}
 
 // PR12884
 namespace PR12884_original {
   template <typename T> struct A {
     struct B {
       template <typename U> struct X {};
       typedef int arg;
     };

clang/unittests/AST/ASTTraverserTest.cpp

)cpp");
   const auto ATL = TL.getNextTypeLoc().getAs<AttributedTypeLoc>();
   const auto *AS = cast<AddressSpaceAttr>(ATL.getAttr());
   EXPECT_EQ(toTargetAddressSpace(static_cast<LangAS>(AS->getAddressSpace())),
             19u);
 }
 
 TEST(Traverse, IgnoreUnlessSpelledInSourceVars) {
 
-  auto AST = buildASTFromCode(R"cpp(
+  auto AST = buildASTFromCodeWithArgs(R"cpp(
 
 struct String
 {
     String(const char*, int = -1) {}
 
     int overloaded() const;
     int& overloaded();
 };
void varDeclCtors() {
   auto var6 = TwoParamCtor(i, 7);
   }
   {
   OneParamCtor var7(i);
   TwoParamCtor var8(i, 7);
   }
 }
 
-)cpp");
+)cpp", {"-std=c++14"});
 
   {
     auto FN =
         ast_matchers::match(functionDecl(hasName("stringConstruct")).bind("fn"),
                             AST->getASTContext());
     EXPECT_EQ(FN.size(), 1u);
 
     EXPECT_EQ(dumpASTString(TK_AsIs, FN[0].getNodeAs<Decl>("fn")),
`-CXXBindTemporaryExpr
       `-CallExpr
         `-ImplicitCastExpr
           `-DeclRefExpr 'someFun'
 )cpp");
 }
 
 TEST(Traverse, IgnoreUnlessSpelledInSourceReturns) {
 
-  auto AST = buildASTFromCode(R"cpp(
+  auto AST = buildASTFromCodeWithArgs(R"cpp(
 
 struct A
 {
 };
 
 struct B
 {
   B(int);
B func11() {
   return b;
 }
 
 B func12() {
   C c;
   return c;
 }
 
-)cpp");
+)cpp", {"-std=c++14"});
 
   auto getFunctionNode = [&AST](const std::string &name) {
     auto BN = ast_matchers::match(functionDecl(hasName(name)).bind("fn"),
                                   AST->getASTContext());
     EXPECT_EQ(BN.size(), 1u);
     return BN[0].getNodeAs<Decl>("fn");
   };
 

llvm/utils/lit/lit/llvm/config.py

def use_clang(self, additional_tool_dirs=[], additional_flags=[],
             self.config.substitutions.append(
                 ('%target_itanium_abi_host_triple',
                  '--target=' + self.make_itanium_abi_triple(
                                    self.config.host_triple)))
         else:
             self.config.substitutions.append(
                 ('%target_itanium_abi_host_triple', ''))
 
+        # Many tests work across many language dialects. We provide substitutions
+        # conveniently try every dialect with LIT_CLANG_STD_GROUP.
+        clang_std_group = int(os.environ.get('LIT_CLANG_STD_GROUP', '0'))
+        clang_std_values = ('98', '11', '14', '17', '20', '2b')
+        def add_stdcxx(s):
+            t = s[8:]
+            if t.endswith('-'):
+                t += clang_std_values[-1]
+            l = clang_std_values.index(t[0:2] if t[0:2] != '23' else '2b')
+            h = clang_std_values.index(t[3:5])
+            # Let LIT_CLANG_STD_GROUP=0 pick the highest value (likely the most relevant
+            # dialect).
+            l = h - clang_std_group % (h-l+1)
+            self.config.substitutions.append((s, '-std=c++' + clang_std_values[l]))
+
+        add_stdcxx('%stdcxx_98-14')
+        add_stdcxx('%stdcxx_98-')
+        add_stdcxx('%stdcxx_11-14')
+        add_stdcxx('%stdcxx_11-')
+        add_stdcxx('%stdcxx_14-')
+        add_stdcxx('%stdcxx_17-20')
+        add_stdcxx('%stdcxx_17-')
+        add_stdcxx('%stdcxx_20-')
+        add_stdcxx('%stdcxx_23-')
+
         # FIXME: Find nicer way to prohibit this.
         def prefer(this, to):
             return '''\"*** Do not use '%s' in tests, use '%s'. ***\"''' % (
                 to, this)
         self.config.substitutions.append(
             (' clang ', prefer('%clang', 'clang')))
         self.config.substitutions.append(
             (r' clang\+\+ ', prefer('%clangxx', 'clang++')))