[clang][OpeMP] Model OpenMP structured-block in AST (PR40563)

[lebedev.ri]

Summary

https://www.openmp.org/wp-content/uploads/OpenMP-API-Specification-5.0.pdf, page 3:

structured block

For C/C++, an executable statement, possibly compound, with a single entry at the
top and a single exit at the bottom, or an OpenMP construct.

COMMENT: See Section 2.1 on page 38 for restrictions on structured
blocks.

2.1 Directive Format

Some executable directives include a structured block. A structured block:
• may contain infinite loops where the point of exit is never reached;
• may halt due to an IEEE exception;
• may contain calls to exit(), _Exit(), quick_exit(), abort() or functions with a
_Noreturn specifier (in C) or a noreturn attribute (in C/C++);
• may be an expression statement, iteration statement, selection statement, or try block, provided
that the corresponding compound statement obtained by enclosing it in { and } would be a
structured block; and

Restrictions
Restrictions to structured blocks are as follows:
• Entry to a structured block must not be the result of a branch.
• The point of exit cannot be a branch out of the structured block.
C / C++
• The point of entry to a structured block must not be a call to setjmp().
• longjmp() and throw() must not violate the entry/exit criteria.

Of particular note here is the fact that OpenMP structured blocks are as-if noexcept,
in the same sense as with the normal noexcept functions in C++.
I.e. if throw happens, and it attempts to travel out of the noexcept function
(here: out of the current structured-block), then the program terminates.

Now, one of course can say that since it is explicitly prohibited by the Specification,
then any and all programs that violate this Specification contain undefined behavior,
and are unspecified, and thus no one should care about them. Just don't write broken code /s

But i'm not sure this is a reasonable approach.
I have personally had oss-fuzz issues of this origin - exception thrown inside
of an OpenMP structured-block that is not caught, thus causing program termination.
This issue isn't all that hard to catch, it's not any particularly different from
diagnosing the same situation with the normal noexcept function.

Now, clang static analyzer does not presently model exceptions.
But clang-tidy has a simplisic bugprone-exception-escape check,
and it is even refactored as a ExceptionAnalyzer class for reuse.
So it would be trivial to use that analyzer to check for
exceptions escaping out of OpenMP structured blocks. (D59466)

All that sounds too great to be true. Indeed, there is a caveat.
Presently, it's practically impossible to do. To check a OpenMP structured block
you need to somehow 'get' the OpenMP structured block, and you can't because
it's simply not modelled in AST. CapturedStmt/CapturedDecl is not it's representation.

Now, it is of course possible to write e.g. some AST matcher that would e.g.
match every OpenMP executable directive, and then return the whatever Stmt is
the structured block of said executable directive, if any.
But i said practically. This isn't practical for the following reasons:

1. This will bitrot. That matcher will need to be kept up-to-date, and refreshed with every new OpenMP spec version.
2. Every single piece of code that would want that knowledge would need to have such matcher. Well, okay, if it is an AST matcher, it could be shared. But then you still have RecursiveASTVisitor and friends. 2 > 1, so now you have code duplication.

So it would be reasonable (and is fully within clang AST spirit) to not
force every single consumer to do that work, but instead store that knowledge
in the correct, and appropriate place - AST, class structure.

Now, there is another hoop we need to get through.
It isn't fully obvious how to model this.
The best solution would of course be to simply add a OMPStructuredBlock transparent
node. It would be optimal, it would give us two properties:

• Given this OMPExecutableDirective, what's it OpenMP structured block?
• It is trivial to check whether the Stmt* is a OpenMP structured block (isa<OMPStructuredBlock>(ptr))

But OpenMP structured block isn't necessarily the first, direct child of OMP*Directive.
(even ignoring the clang's CapturedStmt/CapturedDecl that were inserted inbetween).
So i'm not sure whether or not we could re-create AST statements after they were already created?
There would be other costs to a new AST node: https://bugs.llvm.org/show_bug.cgi?id=40563#c12

1. You will need to break the representation of loops. The body should be replaced by the "structured block" entity.
2. You will need to support serialization/deserialization.
3. You will need to support template instantiation.
4. You will need to support codegen and take this new construct to account in each OpenMP directive.

Instead, there is an functionally-equivalent, alternative solution, consisting of two parts.

Part 1:

• Add a member function isStandaloneDirective() to the OMPExecutableDirective class, that will tell whether this directive is stand-alone or not, as per the spec. We need it because we can't just check for the existance of associated statements, see code comment.
• Add a member function getStructuredBlock() to the OMPExecutableDirective` class itself, that assert that this is not a stand-alone directive, and either return the correct loop body if this is a loop-like directive, or the captured statement.

This way, given an OMPExecutableDirective, we can get it's structured block.
Also, since the knowledge is ingrained into the clang OpenMP implementation,
it will not cause any duplication, and hopefully won't bitrot.

Great we achieved 1 of 2 properties of OMPStructuredBlock approach.

Thus, there is a second part needed:

• How can we check whether a given Stmt* is OMPStructuredBlock?

Well, we can't really, in general. I can see this workaround:

class FunctionASTVisitor : public RecursiveASTVisitor<FunctionASTVisitor> {
  using Base = RecursiveASTVisitor<FunctionASTVisitor>;
public:
  bool VisitOMPExecDir(OMPExecDir *D) {
    OmpStructuredStmts.emplace_back(D.getStructuredStmt());
  }
  bool VisitSOMETHINGELSE(???) {
    if(InOmpStructuredStmt)
      HI!
  }
  bool TraverseStmt(Stmt *Node) {
    if (!Node)
      return Base::TraverseStmt(Node);
    if (OmpStructuredStmts.back() == Node)
      ++InOmpStructuredStmt;
    Base::TraverseStmt(Node);
    if (OmpStructuredStmts.back() == Node) {
      OmpStructuredStmts.pop_back();
      --InOmpStructuredStmt;
    }
    return true;
  }
  std::vector<Stmt*> OmpStructuredStmts;
  int InOmpStructuredStmt = 0;
};

But i really don't see using it in practice.
It's just too intrusive; and again, requires knowledge duplication.

.. but no. The solution lies right on the ground.
Why don't we simply store this i'm a openmp structured block in the bitfield of the Stmt itself?
This does not appear to have any impact on the memory footprint of the clang AST,
since it's just a single extra bit in the bitfield. At least the static assertions don't fail.
Thus, indeed, we can achieve both of the properties without a new AST node.

We can cheaply set that bit right in sema, at the end of Sema::ActOnOpenMPExecutableDirective(),
by just calling the getStructuredBlock() that we just added.
Test coverage that demonstrates all this has been added.

This isn't as great with serialization though. Most of it does not use abbrevs,
so we do end up paying the full price (4 bytes?) instead of a single bit.
That price, of course, can be reclaimed by using abbrevs.
In fact, i suspect that might not just reclaim these bytes, but pack these PCH significantly.

I'm not seeing a third solution. If there is one, it would be interesting to hear about it.
("just don't write code that would require isa<OMPStructuredBlock>(ptr)" is not a solution.)

Fixes PR40563.

[ABataev]

include/clang/AST/StmtOpenMP.h

335 ↗

(On Diff #190079)

No need to insert it into each class, just add:

Stmt * OMPExecutableDirective::getStructuredBlock() const {
  if (!hasAssociatedStmt() || !getAssociatedStmt())
    return nullptr;
  if (auto *LD = dyn_cast<OMPLoopDirective>(this))
    return LD->getBody();
  return getInnermostCapturedStmt()->getCapturedStmt();
}

[gribozavr]

include/clang/AST/StmtOpenMP.h

266 ↗

(On Diff #190079)

"the AST node"

2158 ↗

(On Diff #190079)

This comment (and other similar comments on getStructuredBlockImpl()) are implementation comments and should be written in the function body.

include/clang/Basic/OpenMPKinds.def

18 ↗

(On Diff #190079)

Why not add a default definition:

#  define OPENMP_EXECUTABLE_DIRECTIVE(Name, Class) OPENMP_DIRECTIVE(Name)

(Also for OPENMP_EXECUTABLE_DIRECTIVE_EXT below.)

test/AST/ast-dump-openmp-atomic.c

1 ↗

(On Diff #190079)

I'm not a fan of ast-dump tests. They are fragile, difficult to update, difficult to read (when they are 700 lines long), and it is unclear what the important parts are.

WDYT about converting them to unit tests? See clang/unittests/AST/StmtPrinterTest.cpp for an example.

[gribozavr]

include/clang/AST/StmtOpenMP.h

269 ↗

(On Diff #190079)

Why not Stmt * as a return value?

[lebedev.ri]

Thanks for taking a look, some replies.

include/clang/AST/StmtOpenMP.h

269 ↗

(On Diff #190079)

Good question.

Because usually checking a pointer for null is an exceptional
case, you normally have the AST node, you don't check
every single pointer for null, i don't think?

This is absolutely not the case here, null is not an
exceptional failure state here, it's the expected return value
for stand-alone directives. With Optional, you explicitly
signal "hey, i'm not a plain pointer, pay attention!",
thus hopefully maybe preventing some issues.

I'm not sure we can more nicely solve this with an extra base class[es],
at least not without having only two direct subclasses of OMPExecutableDirective:

• OMPNonstandaloneExecutableDirective.
• OMPStandaloneExecutableDirective.

and two different OMPOrderedDirective classes (one standalone, one not).
But somehow i don't think there is any chance of that being accepted,
even though it would result in slightly cleaner AST.

335 ↗

(On Diff #190079)

I absolutely can do that, you are sure that is the most future-proof state?
In particular, i want to re-point-out that if it's implemented like this,
in the base class, then the sub-class may(will) not even know about this function,
and thus 'forget' to update it, should it not be giving the correct answer for
that new specific OpenMP executable directive.

You are sure it's better to implement it in the OMPExecutableDirective itself?

include/clang/Basic/OpenMPKinds.def

18 ↗

(On Diff #190079)

Hm, i have never seen that chaining pattern in .def headers before,
so it could be surprising behavior.

test/AST/ast-dump-openmp-atomic.c

1 ↗

(On Diff #190079)

They are difficult to update.

The updating part is true, for all of the clang tests,
they unlike llvm tests have no update scripts, so it's a major pain.
Here, it's is actually reasonably simple:

1. prune old // CHECK* lines
2. run the run line
3. prepend each line of output with // CHECK-NEXT:
4. scrub addresses, s/0x[0-9a-f]+/0x{{.*}}/
5. scrub filepath prefix, again a simple string-replace
6. prune everything after TranslationUnitDecl and before first FunctionDecl
7. replace a few // CHECK-NEXT: with // CHECK:
8. append the final processed output to the test file. done.

It would not be too hard to write an update tool for this, but i've managed with a simple macro..

They are fragile, difficult to read (when they are 700 lines long),
and it is unclear what the important parts are.

This is kind-of intentional. I've tried to follow the llvm-proper approach of gigantic
tests that are overly verbose, but quickly cement the state so any change will
be noticed. That has been a very successful approach for LLVM.

In fact, the lack of this ast-dumper test coverage was not helping
the recent ast-dumper refactoring, ask @aaron.ballman / @steveire.

So no, i really don't want to convert the tests into a less verbose state.

I suppose i could add a more fine-grained tests,
though readability is arguable. Here, it is obvious nothing is omitted,
and you can quickly see the openmp_structured_block by Ctrl+F'ing for it.
With more distilled tests, it's less obvious. (i'm not talking about StmtPrinterTest)

[ABataev]

include/clang/AST/StmtOpenMP.h

335 ↗

(On Diff #190079)

Yes, I'm sure. It is the universal solution and all future classes must be compatible with it. If they are not, then they are incorrect.

[gribozavr]

include/clang/AST/StmtOpenMP.h

269 ↗

(On Diff #190079)

Because usually checking a pointer for null is an exceptional
case, you normally have the AST node, you don't check
every single pointer for null, i don't think?

When deciding whether to check for null, we look at the function contract and check those pointers that are nullable. For example, IfStmt::getThen() does not return NULL in valid ASTs, but IfStmt::getElse() does.

This is absolutely not the case here, null is not an
exceptional failure state here, it's the expected return value
for stand-alone directives.

Yes, I understand what optional is and how a new codebase could use it with pointers. However, LLVM and Clang code has not been using optional to indicate nullability for pointers. I could only find 136 occurrences of Optional<.*\*> in llvm-project.git.

include/clang/Basic/OpenMPKinds.def

18 ↗

(On Diff #190079)

It is used in Clang, for example, in llvm/tools/clang/include/clang/AST/TypeNodes.def, or llvm/tools/clang/include/clang/AST/BuiltinTypes.def. I was surprised that this file does not use this pattern, to be honest.

test/AST/ast-dump-openmp-atomic.c

1 ↗

(On Diff #190079)

Here, it's is actually reasonably simple:

Unfortunately, an 8-step process is anything but simple.

This is kind-of intentional. I've tried to follow the llvm-proper approach of gigantic
tests that are overly verbose, but quickly cement the state so any change will
be noticed.

That's pretty much a definition of a "fragile test". The tests should check what they intend to check.

That has been a very successful approach for LLVM.

I don't think LLVM does this, the CHECK lines are for the most part manually crafted.

In fact, the lack of this ast-dumper test coverage was not helping
the recent ast-dumper refactoring, ask @aaron.ballman / @steveire.

If we need tests for AST dumper, we should write tests for it. OpenMP tests should not double for AST dumper tests.

[lebedev.ri]

include/clang/AST/StmtOpenMP.h

335 ↗

(On Diff #190079)

Aha! Well, ok then.

Do you also suggest that Optional<> is too fancy?
Would it be better to do this instead?

bool isStandaloneDirective() const {
  return !hasAssociatedStmt() || !getAssociatedStmt();
}

// Requires: !isStandaloneDirective()
Stmt *OMPExecutableDirective::getStructuredBlock() const {
  assert(!isStandaloneDirective() && "Standalone Executable OpenMP directives don't have structured blocks.")
  if (auto *LD = dyn_cast<OMPLoopDirective>(this))
    return LD->getBody();
  return getInnermostCapturedStmt()->getCapturedStmt();
}

Hm, maybe that actually conveys more meaning..

[lebedev.ri]

test/AST/ast-dump-openmp-atomic.c

1 ↗

(On Diff #190079)

Here, it's is actually reasonably simple:

Unfortunately, an 8-step process is anything but simple.

Hah, what i was saying is that it is entirely automatable,
all steps are identical each time.

That's pretty much a definition of a "fragile test". The tests should check what they intend to check.
I don't think LLVM does this, the CHECK lines are for the most part manually crafted.

No.
I know that 'most' of the new/updated tests are not manual,
from looking at the tests in commits, it's not an empty statement.

llvm/test/CodeGen$ for i in `ls -1d *`; do echo -n "$i "; find $i -iname \*.ll | xargs grep "update_llc" | wc -l; done | sort -r -n -k 2,2
X86 1427
PowerPC 125
RISCV 90
...

llvm/test/CodeGen$ find X86/ -iname *.ll | wc -l
3370
llvm/test/CodeGen$ find PowerPC/ -iname *.ll | wc -l
1019
llvm/test/CodeGen$ find RISCV/ -iname *.ll | wc -l
105

So a half of X86 backend tests, and pretty much all RISCV backend tests.

llvm/test$ for i in `ls -1d *`; do echo -n "$i "; find $i -iname \*.ll | xargs grep "update_test" | wc -l; done | sort -r -n -k 2,2
Transforms 845
Analysis 17
CodeGen 6
Other 2

$ for i in `ls -1d *`; do echo -n "$i "; find $i -iname \*.ll | wc -l; done | sort -r -n -k 2,2
Transforms 4620
Analysis 804

So sure, by the numbers, 'most' aren't auto-generated.
It's a question of legacy mainly.

I've both added llvm tests, and clang tests.
llvm tests are a breeze, just come up with sufficient IR,
and run the script [verify that the CHECK is what you thought it is,
or tune IR until it is], and you're done. With clang (codegen mostly),
one needs to first come up with the test, and then with the check lines,
and be really careful not to misspell CHECK, or else you're suddenly
not testing anything. clang tests are at least 3x more time-costly,
and i suspect thus have much less coverage they could have.

If we need tests for AST dumper, we should write tests for it. OpenMP tests should not double for AST dumper tests.

I'll take a look at StmtPrinterTest, but i'm not sure i agree it's better.

[lebedev.ri]

include/clang/AST/StmtOpenMP.h

335 ↗

(On Diff #190079)

Great, that doesn't work, and highlights my concerns.
target enter data / target exit data / target update are stand-alone directives as per the spec,
but not as per that isStandaloneDirective() check ^.
https://godbolt.org/z/0tE93s

Is this a bug, or intentional?

[ABataev]

include/clang/AST/StmtOpenMP.h

335 ↗

(On Diff #190079)

Well, this is an incompatibility caused by previous not-quite correct implementation. It was reworked already, but these incorrect children still remain, I just had no time to clean them out. You can fix this.

[lebedev.ri]

include/clang/AST/StmtOpenMP.h

335 ↗

(On Diff #190079)

Okay, that is reassuring, thanks.

[gribozavr]

test/AST/ast-dump-openmp-atomic.c

1 ↗

(On Diff #190079)

Hah, what i was saying is that it is entirely automatable, all steps are identical each time.

What about the issue of reviewing the resulting diffs? How likely is that the programmer will notice an unintended change in the sea of diffs?

If my arguments don't convince you, here's some industry wisdom: https://testing.googleblog.com/2015/01/testing-on-toilet-change-detector-tests.html

[lebedev.ri]

include/clang/AST/StmtOpenMP.h

335 ↗

(On Diff #190079)

this is an incompatibility caused by previous not-quite correct implementation. It was reworked already,
but these incorrect children still remain, I just had no time to clean them out. You can fix this.

I have looked into this, and while parsing/sema changes are trivial, it has consequences for CodeGen.
In particular CodeGenFunction::EmitOMPTargetEnterDataDirective() & friends can no longer
create OMPLexicalScope with OMPD_task, or else it will assert that there are no associated stmts.

And more importantly, in the end CodeGenFunction::EmitOMPTargetTaskBasedDirective() tries to, again,
get these assoc stmts, and fails. I'm guessing it shouldn't just bailout, then it would not emit anything?

Any hints would be appreciated.

[ABataev]

include/clang/AST/StmtOpenMP.h

335 ↗

(On Diff #190079)

Ahh, now I recall why it was required. It is needed to support the asynchronous data transfers. It can be reworked to avoid adding those special associated statements but it requires significant amount of time.
You can just add a check for those 3 directives in this Stmt *OMPExecutableDirective::getStructuredBlock() and return nullptr for them explicitly. I think it is still better than adding a whole bunch of those getStructuredStmt functions for each class. Plus, using this single function, you can apply it to the base OMPExecutableDirective class rather than to the derived classes. Some matchers could prefer to do this.

[lebedev.ri]

Addressed review notes
Split off baseline tests to a separate diff, to actually demonstrate the diff
Did not add more fine-grained tests as of this moment.

[riccibruno]

IIRC, last time I looked only 4 statement/expression classes currently have some abbreviation defined. It would probably be useful to have someone go systematically through the list of classes and fix this.

[lebedev.ri]

In D59214#1429384, @riccibruno wrote:

IIRC, last time I looked only 4 statement/expression classes currently have some abbreviation defined.

Yep, that is what i'm seeing in this diff.

In D59214#1429384, @riccibruno wrote:

It would probably be useful to have someone go systematically through the list of classes and fix this.

Yeah, i suspect that might be really beneficial.

[riccibruno]

In D59214#1429400, @lebedev.ri wrote:

In D59214#1429384, @riccibruno wrote:

IIRC, last time I looked only 4 statement/expression classes currently have some abbreviation defined.

Yep, that is what i'm seeing in this diff.

In D59214#1429384, @riccibruno wrote:

It would probably be useful to have someone go systematically through the list of classes and fix this.

Yeah, i suspect that might be really beneficial.

Especially given that more people are going to use modules now that they are in the process of being standardized.

[lebedev.ri]

In D59214#1429422, @riccibruno wrote:

In D59214#1429400, @lebedev.ri wrote:

In D59214#1429384, @riccibruno wrote:

IIRC, last time I looked only 4 statement/expression classes currently have some abbreviation defined.

Yep, that is what i'm seeing in this diff.

In D59214#1429384, @riccibruno wrote:

It would probably be useful to have someone go systematically through the list of classes and fix this.

Yeah, i suspect that might be really beneficial.

Especially given that more people are going to use modules now that they are in the process of being standardized.

Ah, good point, filed https://bugs.llvm.org/show_bug.cgi?id=41072

[riccibruno]

include/clang/AST/Stmt.h

100 ↗

(On Diff #190437)

What about a comment explaining the purpose of this bit ?

include/clang/AST/StmtOpenMP.h

274 ↗

(On Diff #190437)

This is not const-correct. The const-qualified method should return a const Stmt *.

[lebedev.ri]

include/clang/AST/StmtOpenMP.h

274 ↗

(On Diff #190437)

Hmm, true; though that is not uncommon for all of clang.
I guess it will be best to return const-qualified here, and add a wrapper that would cast it away.

[lebedev.ri]

Added more fine-grained tests.

Hopefully all good now ?

[riccibruno]

include/clang/AST/StmtOpenMP.h

274 ↗

(On Diff #190957)

Uh, and what about the non-const version of getStructuredBlock ? I think that you just have to do the usual const_cast dance to implement the non-const version in term of the const version.

Apart from this I have no other comment.

[lebedev.ri]

lib/AST/StmtOpenMP.cpp

40 ↗

(On Diff #190957)

@riccibruno
getBody() exists in const-only variant
getInnermostCapturedStmt() does exist in both the const and non-const variants,
but the const variant does const_cast and defers to non-const variant.
getCapturedStmt() is good though.

So at best i can add

Stmt *getStructuredBlock() {
  return const_cast<Stmt *>(const_cast<OMPExecutableDirective *>(this)->getStructuredBlock());
}

I'm not sure it's worth it?

[lebedev.ri]

Drop unused helper from unit test.

[riccibruno]

lib/AST/StmtOpenMP.cpp

40 ↗

(On Diff #190957)

Or perhaps something like the following to avoid one const_cast:

Stmt *getStructuredBlock() {
  const OMPExecutableDirective *ConstThis = this;
  return const_cast<Stmt *>(ConstThis->getStructuredBlock());
}

My point is that in itself this is a minor thing, but not defining consistently both versions (when appropriate) inevitably leads to annoying errors. For example suppose that you only define the const version of getStructuredBlock(), and then there is some random function bar with the signature void bar(Stmt *S).

You then try:

// Intentionally not `const Stmt *` since we will set some random flag in S.
void bar(Stmt *S);

// Non-const since we are modifying it.
OMPExecutableDirective *OED = something;
bar(OED->getStructuredBlock())

which fails because OED->getStructuredBlock() has type const Stmt*, even though every other pointee type is non-const qualified.

So unless it is intentional to forbid modifying the statement returned by getStructuredBlock(), defining both versions of getStructuredBlock() avoid this problem. Yes it is annoying to have to define the two versions but as far as I know this is inherent to C++ unfortunately.

[lebedev.ri]

lib/AST/StmtOpenMP.cpp

40 ↗

(On Diff #190957)

Hmm, okay, will add during next update / before landing, whichever happens next.

[riccibruno]

lib/AST/StmtOpenMP.cpp

40 ↗

(On Diff #190957)

Sounds good.

[gribozavr]

include/clang/AST/Stmt.h

102 ↗

(On Diff #190959)

"non-standalone OpenMP executable directives"

test/PCH/stmt-openmp_structured_block-bit.cpp

8 ↗

(On Diff #190959)

Maybe try imitating a more recently written test, like llvm/tools/clang/test/PCH/cxx2a-compare.cpp ? It has both header and user written in the same file, for improved readability.

test/PCH/stmt-openmp_structured_block-bit.h

2 ↗

(On Diff #190959)

Is cxx_exprs.h needed?

I don't think -std=c++11 is needed either.

Same in RUN lines below.

Maybe try imitating a more recently written test, like llvm/tools/clang/test/PCH/cxx2a-compare.cpp ?

5 ↗

(On Diff #190959)

The point of PCH tests is to test the serialization of ASTs into PCH. In this line the cxx_exprs.h header is being initialized, it does not contain any OpenMP constructs, so I'm not sure what this test is supposed to test.

6 ↗

(On Diff #190959)

I don't see any CHECK lines for FileCheck. (FileCheck fails the test if there are no CHECK lines.)

unittests/AST/OMPStructuredBlockTest.cpp

9 ↗

(On Diff #190959)

"of Stmt"

27 ↗

(On Diff #190959)

Eventually you'll move it to ASTMatchers.h, right?

41 ↗

(On Diff #190959)

extra "k" before "Matcher"

unittests/AST/PrintTest.h

15 ↗

(On Diff #190959)

Please don't write using namespace in headers. Instead, put the code below into the clang namespace.

19 ↗

(On Diff #190959)

No need for this, make PrintStmt() static.

[lebedev.ri]

Before i do address any further bike^W review notes in other
reviews in this path stack, i want to finish with this review.
If this change doesn't stick, rest is pointless waste of everyone's time.

@ABataev please do tell if there is any outstanding issues here.
I think i have addressed everything..

[gribozavr]

As far as I'm concerned, I don't have any major revision requests. I haven't reviewed the unit tests (I'm planning to), but for non-test code, I don't have any further comments.

[ABataev]

The OpenMP part looks good.

[gribozavr]

unittests/AST/OMPStructuredBlockTest.cpp

64 ↗

(On Diff #190959)

Same comment as in the other patch -- I would prefer that the source is inlined into the ASSERT_TRUE, with implicit string concatenation and "\n"s, if raw strings don't work.

75 ↗

(On Diff #190959)

Could you also add an assertion that OMPStructuredBlockMatcher() matches zero AST nodes? Similarly in every test that has no structured blocks.

121 ↗

(On Diff #190959)

This test file repeats this pattern many times, only with different OpenMP directives:

TEST(OMPStructuredBlock, Test~~~Directive0)
TEST(OMPStructuredBlock, Test~~~Directive1)
TEST(OMPStructuredBlock, Test~~~DirectiveCollapse1)
TEST(OMPStructuredBlock, Test~~~DirectiveCollapse2)
TEST(OMPStructuredBlock, Test~~~DirectiveCollapse22)

WDYT about deduplicating it using parameterized tests? For example, see AssignmentTest in llvm/tools/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp.

656 ↗

(On Diff #190959)

Is it only a pretty-printer problem or something more severe?

704 ↗

(On Diff #190959)

Extra "k" before "Matcher".

712 ↗

(On Diff #190959)

Extra "k" before "Matcher".

1481 ↗

(On Diff #190959)

"TestTeams"

unittests/AST/PrintTest.h

1 ↗

(On Diff #190959)

"ASTPrint.h"?

[lebedev.ri]

unittests/AST/OMPStructuredBlockTest.cpp

64 ↗

(On Diff #190959)

I still don't understand the reasoning here.
It feels like a change just for the sake of the change.

[gribozavr]

unittests/AST/OMPStructuredBlockTest.cpp

64 ↗

(On Diff #190959)

These variables don't improve readability. Also, if there are multiple such variables in one test, it is easy to mistakenly use an incorrect one in the ASSERT_TRUE line.

[lebedev.ri]

Addressed all nits excluding the removal of multiline string literals.

In D59214#1433283, @ABataev wrote:

The OpenMP part looks good.

Great. Can you stamp this then please? :)

include/clang/AST/Stmt.h

102 ↗

(On Diff #190959)

English isn't my native language; to me the current variant (attempts to?) convey
that structured block can only ever exist for non-standalone executable directives.
I.e. "structured block of non-standalone executable directives" is a misnomer.

The variant without [] does not convey any of that, i think, it just says
that "it's a structured block of non-standalone OpenMP executable directives",
it isn't obvious from that (without knowing OpenMP details) that there
wouldn't be "a structured block of standalone OpenMP executable directive".

Isn't there an important difference there?

unittests/AST/OMPStructuredBlockTest.cpp

64 ↗

(On Diff #190959)

Can you please quote something about this from
https://llvm.org/docs/CodingStandards.html
https://llvm.org/docs/ProgrammersManual.html
etc?
If not this is entirely subjective/stylistic,
and this was the form that was more readable to me.
(easier to write, too, those "\n" will look horrible)
Also, what about the cases with two assertions? (not just the new ones)

I really don't see how that would be a good change.

656 ↗

(On Diff #190959)

PR41022.

[gribozavr]

include/clang/AST/Stmt.h

102 ↗

(On Diff #190959)

I didn't catch this difference implied by "[]".

I.e. "structured block of non-standalone executable directives" is a misnomer.

Why is it a misnomer? It might be overly verbose, but it is correct.

However, I see that this fact is important to highlight, so I'd suggest to spell it out:

"This bit is set only for the Stmts that are the structured-block of OpenMP executable directives. Directives that have a structured block are called "non-standalone" directives."

Please also fix the typo "OpeMP" => OpenMP.

unittests/AST/OMPStructuredBlockTest.cpp

64 ↗

(On Diff #190959)

There are lots of readability points that are not formalized in the coding style, and yet, are followed in the code.

For cases with two assertions we need to have a variable to avoid code duplication, so it is OK there -- the variable has a purpose.

If you want to use raw string literals, could I at least ask you to drop the first line onto the same level of indentation as the rest of the lines?

  const char *Source =
      R"(void test(int i) {
#pragma omp atomic
++i;
})";

change to:

  const char *Source = R"(
void test(int i) {
#pragma omp atomic
++i;
})";

[ABataev]

LG for the OpenMP part

[lebedev.ri]

Few last nits.

@ABataev @gribozavr thank you for the reviews!

include/clang/AST/Stmt.h

102 ↗

(On Diff #190959)

I.e. "structured block of non-standalone executable directives" is a misnomer.

Why is it a misnomer? It might be overly verbose, but it is correct.

Blargh.
I meant to write "structured block of *standalone* executable directives" would make no sense.

".."

Yes, that looks cleaner, thank you!

unittests/AST/OMPStructuredBlockTest.cpp

64 ↗

(On Diff #190959)

If you want to use raw string literals, could I at least ask you to drop the first line onto the same level of indentation as the rest of the lines?

Absolutely.

[rupprecht]

cfe/trunk/unittests/AST/OMPStructuredBlockTest.cpp

58

Looks like this test fails when the default is not libomp, e.g. DCLANG_DEFAULT_OPENMP_RUNTIME=libgomp
Using -fopenmp=libomp explicitly here causes the test to pass in the case. Does that seem like the right fix, or has something gone wrong?

[sammccall]

So if I understand the history here:

• the IsOMPStructuredBlock bit on Stmt was added to implement getStructuredBlock()
• after review, getStructuredBlock() doesn't use the bit
• the bit is used in the textual AST dump, and an AST matcher (which is in turn never used in-tree)

Can we have the bit back please :-)
We're currently trying to add a HasErrors bit to improve error-recovery and some nodes are completely full.
Using a bit on every Stmt to improve the text dump a little and provide a matcher (only relevant to OMP files) seems disproportionately expensive.

[rjmccall]

If the bit is unused except for propagation, please remove it.

[lebedev.ri]

In D59214#1916596, @sammccall wrote:

So if I understand the history here:

• the IsOMPStructuredBlock bit on Stmt was added to implement getStructuredBlock()
• after review, getStructuredBlock() doesn't use the bit
• the bit is used in the textual AST dump, and an AST matcher (which is in turn never used in-tree)

Can we have the bit back please :-)
We're currently trying to add a HasErrors bit to improve error-recovery and some nodes are completely full.
Using a bit on every Stmt to improve the text dump a little and provide a matcher (only relevant to OMP files) seems disproportionately expensive.

In D59214#1917106, @rjmccall wrote:

If the bit is unused except for propagation, please remove it.

This review (& https://bugs.llvm.org/show_bug.cgi?id=40563 in general)
has left me so burnout as to all this openmp stuff that i never
followed-up with the actual planned usages of this bit.

The reasons why this bit is needed (i think they were spelled out here)
still apply. One obvious example is https://bugs.llvm.org/show_bug.cgi?id=41102,
where after we'd teach ExceptionAnalyzer to look into CapturedStmt / CapturedDecl,
we'd immediately have false-positives for these OpenMP structured blocks,
so we'd need to avoid traversing into them.

Doing that via a single bit check should be trivial, as opposed to,
i dunno, maintainting a set of all the openmp structured block statements,
and before visiting each statement seeing if it is in that set?
That kinda sounds slow.

[rjmccall]

In D59214#1917149, @lebedev.ri wrote:

In D59214#1916596, @sammccall wrote:

So if I understand the history here:

• the IsOMPStructuredBlock bit on Stmt was added to implement getStructuredBlock()
• after review, getStructuredBlock() doesn't use the bit
• the bit is used in the textual AST dump, and an AST matcher (which is in turn never used in-tree)

Can we have the bit back please :-)
We're currently trying to add a HasErrors bit to improve error-recovery and some nodes are completely full.
Using a bit on every Stmt to improve the text dump a little and provide a matcher (only relevant to OMP files) seems disproportionately expensive.

In D59214#1917106, @rjmccall wrote:

If the bit is unused except for propagation, please remove it.

This review (& https://bugs.llvm.org/show_bug.cgi?id=40563 in general)
has left me so burnout as to all this openmp stuff that i never
followed-up with the actual planned usages of this bit.

I'm sorry to hear that.

The reasons why this bit is needed (i think they were spelled out here)
still apply. One obvious example is https://bugs.llvm.org/show_bug.cgi?id=41102,
where after we'd teach ExceptionAnalyzer to look into CapturedStmt / CapturedDecl,
we'd immediately have false-positives for these OpenMP structured blocks,
so we'd need to avoid traversing into them.

Doing that via a single bit check should be trivial, as opposed to,
i dunno, maintainting a set of all the openmp structured block statements,
and before visiting each statement seeing if it is in that set?
That kinda sounds slow.

Well, two points.

The first is that language dialects have to take a back-seat to general-purpose
mechanisms. I care a lot about Objective-C ARC, and that dialect has some
type qualifiers that are used very frequently, but the representation does not
and will never prioritize those type qualifiers over things that are common to
C/C++, and so we just use extra memory when compiling ARC.

The second is that we can pretty easily solve your problem without adding a
bit to Stmt. Captured statements are like blocks in the sense that traverses
that walk into captured statements will always pass through a node in the AST
that knows it's introducing a captured statement, so they should be easy to just
record that the traversal is currently within a captured statement, or even
maintain a stack of such contexts. If it helps to add "callbacks" to some CRTP
visitor class when entering and exiting a special local context, we can do that.

[lebedev.ri]

d5edcb90643104d6911da5c0ff44c4f33fff992f, looking forward to seeing better error recovery.

[sammccall]

In D59214#1919183, @lebedev.ri wrote:

d5edcb90643104d6911da5c0ff44c4f33fff992f, looking forward to seeing better error recovery.

Thanks very much for your help Roman, I'm also sorry this has been difficult.

The plan for error recovery is to add a RecoveryExpr to the AST that can represent the known structure of an invalid expression (e.g. a function call with no viable overloads - this has subexpressions and possibly a known type) instead of dropping it as we do today. This will be used to improve diagnostics and also expose a more meaningful AST to tools.

A "transitive-has-errors" bit on Expr is needed as various places currently assume that if an Expr exists, the code is valid. (TypoExpr is a complicated special snowflake, and we should also be able to reduce the number of places that special-case it).

[lebedev.ri]

In D59214#1926978, @sammccall wrote:

In D59214#1919183, @lebedev.ri wrote:

d5edcb90643104d6911da5c0ff44c4f33fff992f, looking forward to seeing better error recovery.

Thanks very much for your help Roman, I'm also sorry this has been difficult.

The plan for error recovery is to add a RecoveryExpr to the AST that can represent the known structure of an invalid expression (e.g. a function call with no viable overloads - this has subexpressions and possibly a known type) instead of dropping it as we do today. This will be used to improve diagnostics and also expose a more meaningful AST to tools.

A "transitive-has-errors" bit on Expr is needed as various places currently assume that if an Expr exists, the code is valid. (TypoExpr is a complicated special snowflake, and we should also be able to reduce the number of places that special-case it).

Yep, sounds reasonable, thank you for the explanation; that does match my expectations
as i was paying some attention to the previous related discussions.

cfe/trunk/include/clang/AST/Stmt.h

protected:
 
   void operator delete(void *data) noexcept {
     llvm_unreachable("Stmts cannot be released with regular 'delete'.");
   }
 
   //===--- Statement bitfields classes ---===//
 
   class StmtBitfields {
+    friend class ASTStmtReader;
+    friend class ASTStmtWriter;
     friend class Stmt;
 
     /// The statement class.
     unsigned sClass : 8;
+
+    /// This bit is set only for the Stmts that are the structured-block of
+    /// OpenMP executable directives. Directives that have a structured block
+    /// are called "non-standalone" directives.
+    /// I.e. those returned by OMPExecutableDirective::getStructuredBlock().
+    unsigned IsOMPStructuredBlock : 1;
   };
-  enum { NumStmtBits = 8 };
+  enum { NumStmtBits = 9 };
 
   class NullStmtBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
     friend class NullStmt;
 
     unsigned : NumStmtBits;
 

 
 public:
   Stmt(StmtClass SC) {
     static_assert(sizeof(*this) <= 8,
                   "changing bitfields changed sizeof(Stmt)");
     static_assert(sizeof(*this) % alignof(void *) == 0,
                   "Insufficient alignment!");
     StmtBits.sClass = SC;
+    StmtBits.IsOMPStructuredBlock = false;
     if (StatisticsEnabled) Stmt::addStmtClass(SC);
   }
 
   StmtClass getStmtClass() const {
     return static_cast<StmtClass>(StmtBits.sClass);
   }
 
   const char *getStmtClassName() const;
 
+  bool isOMPStructuredBlock() const { return StmtBits.IsOMPStructuredBlock; }
+  void setIsOMPStructuredBlock(bool IsOMPStructuredBlock) {
+    StmtBits.IsOMPStructuredBlock = IsOMPStructuredBlock;
+  }
+
   /// SourceLocation tokens are not useful in isolation - they are low level
   /// value objects created/interpreted by SourceManager. We assume AST
   /// clients will have a pointer to the respective SourceManager.
   SourceRange getSourceRange() const LLVM_READONLY;
   SourceLocation getBeginLoc() const LLVM_READONLY;
   SourceLocation getEndLoc() const LLVM_READONLY;
 
   // global temp stats (until we have a per-module visitor)

cfe/trunk/include/clang/AST/StmtOpenMP.h

child_range children() {
     return child_range(ChildStorage, ChildStorage + 1);
   }
 
   ArrayRef<OMPClause *> clauses() { return getClauses(); }
 
   ArrayRef<OMPClause *> clauses() const {
     return const_cast<OMPExecutableDirective *>(this)->getClauses();
   }
+
+  /// Returns whether or not this is a Standalone directive.
+  ///
+  /// Stand-alone directives are executable directives
+  /// that have no associated user code.
+  bool isStandaloneDirective() const;
+
+  /// Returns the AST node representing OpenMP structured-block of this
+  /// OpenMP executable directive,
+  /// Prerequisite: Executable Directive must not be Standalone directive.
+  const Stmt *getStructuredBlock() const;
+
+  Stmt *getStructuredBlock() {
+    return const_cast<Stmt *>(
+        const_cast<const OMPExecutableDirective *>(this)->getStructuredBlock());
+  }
 };
 
 /// This represents '#pragma omp parallel' directive.
 ///
 /// \code
 /// #pragma omp parallel private(a,b) reduction(+: c,d)
 /// \endcode
 /// In this example directive '#pragma omp parallel' has clauses 'private'

cfe/trunk/include/clang/AST/TextNodeDumper.h

#include "clang/AST/AttrTextNodeDump.inc"
   void VisitFunctionDecl(const FunctionDecl *D);
   void VisitFieldDecl(const FieldDecl *D);
   void VisitVarDecl(const VarDecl *D);
   void VisitBindingDecl(const BindingDecl *D);
   void VisitCapturedDecl(const CapturedDecl *D);
   void VisitImportDecl(const ImportDecl *D);
   void VisitPragmaCommentDecl(const PragmaCommentDecl *D);
   void VisitPragmaDetectMismatchDecl(const PragmaDetectMismatchDecl *D);
+  void VisitOMPExecutableDirective(const OMPExecutableDirective *D);
   void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D);
   void VisitOMPRequiresDecl(const OMPRequiresDecl *D);
   void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D);
   void VisitNamespaceDecl(const NamespaceDecl *D);
   void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D);
   void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D);
   void VisitTypeAliasDecl(const TypeAliasDecl *D);
   void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D);

cfe/trunk/lib/AST/StmtOpenMP.cpp

 using namespace clang;
 
 void OMPExecutableDirective::setClauses(ArrayRef<OMPClause *> Clauses) {
   assert(Clauses.size() == getNumClauses() &&
          "Number of clauses is not the same as the preallocated buffer");
   std::copy(Clauses.begin(), Clauses.end(), getClauses().begin());
 }
 
+bool OMPExecutableDirective::isStandaloneDirective() const {
+  // Special case: 'omp target enter data', 'omp target exit data',
+  // 'omp target update' are stand-alone directives, but for implementation
+  // reasons they have empty synthetic structured block, to simplify codegen.
+  if (isa<OMPTargetEnterDataDirective>(this) ||
+      isa<OMPTargetExitDataDirective>(this) ||
+      isa<OMPTargetUpdateDirective>(this))
+    return true;
+  return !hasAssociatedStmt() || !getAssociatedStmt();
+}
+
+const Stmt *OMPExecutableDirective::getStructuredBlock() const {
+  assert(!isStandaloneDirective() &&
+         "Standalone Executable Directives don't have Structured Blocks.");
+  if (auto *LD = dyn_cast<OMPLoopDirective>(this))
+    return LD->getBody();
+  return getInnermostCapturedStmt()->getCapturedStmt();
+}
+
 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) {
   assert(A.size() == getCollapsedNumber() &&
          "Number of loop counters is not the same as the collapsed number");
   std::copy(A.begin(), A.end(), getCounters().begin());
 }
 
 void OMPLoopDirective::setPrivateCounters(ArrayRef<Expr *> A) {
   assert(A.size() == getCollapsedNumber() && "Number of loop private counters "

cfe/trunk/lib/AST/TextNodeDumper.cpp

void TextNodeDumper::Visit(const Stmt *Node) {
   }
   {
     ColorScope Color(OS, ShowColors, StmtColor);
     OS << Node->getStmtClassName();
   }
   dumpPointer(Node);
   dumpSourceRange(Node->getSourceRange());
 
+  if (Node->isOMPStructuredBlock())
+    OS << " openmp_structured_block";
+
   if (const auto *E = dyn_cast<Expr>(Node)) {
     dumpType(E->getType());
 
     {
       ColorScope Color(OS, ShowColors, ValueKindColor);
       switch (E->getValueKind()) {
       case VK_RValue:
         break;
if (!Arg.empty())
     OS << " \"" << Arg << "\"";
 }
 
 void TextNodeDumper::VisitPragmaDetectMismatchDecl(
     const PragmaDetectMismatchDecl *D) {
   OS << " \"" << D->getName() << "\" \"" << D->getValue() << "\"";
 }
 
+void TextNodeDumper::VisitOMPExecutableDirective(
+    const OMPExecutableDirective *D) {
+  if (D->isStandaloneDirective())
+    OS << " openmp_standalone_directive";
+}
+
 void TextNodeDumper::VisitOMPDeclareReductionDecl(
     const OMPDeclareReductionDecl *D) {
   dumpName(D);
   dumpType(D->getType());
   OS << " combiner";
   dumpPointer(D->getCombiner());
   if (const auto *Initializer = D->getInitializer()) {
     OS << " initializer";

cfe/trunk/lib/Sema/SemaOpenMP.cpp

StmtResult Sema::ActOnOpenMPExecutableDirective(
   case OMPD_declare_mapper:
   case OMPD_declare_simd:
   case OMPD_requires:
     llvm_unreachable("OpenMP Directive is not allowed");
   case OMPD_unknown:
     llvm_unreachable("Unknown OpenMP directive");
   }
 
+  ErrorFound = Res.isInvalid() || ErrorFound;
+
   for (const auto &P : VarsWithInheritedDSA) {
     Diag(P.second->getExprLoc(), diag::err_omp_no_dsa_for_variable)
         << P.first << P.second->getSourceRange();
   }
   ErrorFound = !VarsWithInheritedDSA.empty() || ErrorFound;
 
   if (!AllowedNameModifiers.empty())
     ErrorFound = checkIfClauses(*this, Kind, Clauses, AllowedNameModifiers) ||
                  ErrorFound;
 
   if (ErrorFound)
     return StmtError();
+
+  if (!(Res.getAs<OMPExecutableDirective>()->isStandaloneDirective())) {
+    Res.getAs<OMPExecutableDirective>()
+        ->getStructuredBlock()
+        ->setIsOMPStructuredBlock(true);
+  }
+
   return Res;
 }
 
 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(
     DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen,
     ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
     ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
     ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {

cfe/trunk/lib/Serialization/ASTReaderStmt.cpp

class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
     }
 
   public:
     ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
         : Record(Record), DeclsCursor(Cursor) {}
 
     /// The number of record fields required for the Stmt class
     /// itself.
-    static const unsigned NumStmtFields = 0;
+    static const unsigned NumStmtFields = 1;
 
     /// The number of record fields required for the Expr class
     /// itself.
     static const unsigned NumExprFields = NumStmtFields + 7;
 
     /// Read and initialize a ExplicitTemplateArgumentList structure.
     void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
                                    TemplateArgumentLoc *ArgsLocArray,
void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
   ArgInfo.setLAngleLoc(ReadSourceLocation());
   ArgInfo.setRAngleLoc(ReadSourceLocation());
   for (unsigned i = 0; i != NumTemplateArgs; ++i)
     ArgInfo.addArgument(Record.readTemplateArgumentLoc());
   Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
 }
 
 void ASTStmtReader::VisitStmt(Stmt *S) {
+  S->setIsOMPStructuredBlock(Record.readInt());
   assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
 }
 
 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
   VisitStmt(S);
   S->setSemiLoc(ReadSourceLocation());
   S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt();
 }

cfe/trunk/lib/Serialization/ASTWriterDecl.cpp

void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
   DeclCXXMethodAbbrev = Stream.EmitAbbrev(std::move(Abv));
 
   // Abbreviation for EXPR_DECL_REF
   Abv = std::make_shared<BitCodeAbbrev>();
   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
   //Stmt
-  //Expr
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
+  // Expr
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
   //DeclRefExpr
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
                            1)); // RefersToEnclosingVariableOrCapture
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
   DeclRefExprAbbrev = Stream.EmitAbbrev(std::move(Abv));
 
   // Abbreviation for EXPR_INTEGER_LITERAL
   Abv = std::make_shared<BitCodeAbbrev>();
   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
   //Stmt
-  //Expr
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
+  // Expr
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
   //Integer Literal
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
   Abv->Add(BitCodeAbbrevOp(32));                      // Bit Width
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
   IntegerLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
 
   // Abbreviation for EXPR_CHARACTER_LITERAL
   Abv = std::make_shared<BitCodeAbbrev>();
   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
   //Stmt
-  //Expr
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
+  // Expr
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
   //Character Literal
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // getKind
   CharacterLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
 
   // Abbreviation for EXPR_IMPLICIT_CAST
   Abv = std::make_shared<BitCodeAbbrev>();
   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_IMPLICIT_CAST));
   // Stmt
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
   // Expr
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind

cfe/trunk/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::AddTemplateKWAndArgsInfo(
   Record.AddSourceLocation(ArgInfo.TemplateKWLoc);
   Record.AddSourceLocation(ArgInfo.LAngleLoc);
   Record.AddSourceLocation(ArgInfo.RAngleLoc);
   for (unsigned i = 0; i != ArgInfo.NumTemplateArgs; ++i)
     Record.AddTemplateArgumentLoc(Args[i]);
 }
 
 void ASTStmtWriter::VisitStmt(Stmt *S) {
+  Record.push_back(S->StmtBits.IsOMPStructuredBlock);
 }
 
 void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
   VisitStmt(S);
   Record.AddSourceLocation(S->getSemiLoc());
   Record.push_back(S->NullStmtBits.HasLeadingEmptyMacro);
   Code = serialization::STMT_NULL;
 }

cfe/trunk/test/AST/ast-dump-openmp-atomic.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test(int i) {
 #pragma omp atomic
   ++i;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-atomic.c:3:1, line:6:1> line:3:6 test 'void (int)'
 // CHECK-NEXT:   |-ParmVarDecl {{.*}} <col:11, col:15> col:15 used i 'int'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:18, line:6:1>
 // CHECK-NEXT:     `-OMPAtomicDirective {{.*}} <line:4:9, col:19>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3, col:5>
 // CHECK-NEXT:         |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT:         | |-UnaryOperator {{.*}} <col:3, col:5> 'int' prefix '++'
+// CHECK-NEXT:         | |-UnaryOperator {{.*}} <col:3, col:5> openmp_structured_block 'int' prefix '++'
 // CHECK-NEXT:         | | `-DeclRefExpr {{.*}} <col:5> 'int' lvalue ParmVar {{.*}} 'i' 'int'
 // CHECK-NEXT:         | `-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-atomic.c:4:9) *const restrict'
 // CHECK-NEXT:         `-DeclRefExpr {{.*}} <line:5:5> 'int' lvalue ParmVar {{.*}} 'i' 'int'

cfe/trunk/test/AST/ast-dump-openmp-barrier.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp barrier
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-barrier.c:3:1, line:5:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:5:1>
-// CHECK-NEXT:     `-OMPBarrierDirective {{.*}} <line:4:9, col:20>
+// CHECK-NEXT:     `-OMPBarrierDirective {{.*}} <line:4:9, col:20> openmp_standalone_directive

cfe/trunk/test/AST/ast-dump-openmp-cancel.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp parallel
   {
 #pragma omp cancel parallel
   }
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-cancel.c:3:1, line:8:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:8:1>
 // CHECK-NEXT:     `-OMPParallelDirective {{.*}} <line:4:9, col:21>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3, line:7:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |-CompoundStmt {{.*}} <line:5:3, line:7:3>
-// CHECK-NEXT:           | `-OMPCancelDirective {{.*}} <line:6:9, col:28>
+// CHECK-NEXT:           |-CompoundStmt {{.*}} <line:5:3, line:7:3> openmp_structured_block
+// CHECK-NEXT:           | `-OMPCancelDirective {{.*}} <line:6:9, col:28> openmp_standalone_directive
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-cancel.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-cancellation-point.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp parallel
   {
 #pragma omp cancellation point parallel
   }
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-cancellation-point.c:3:1, line:8:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:8:1>
 // CHECK-NEXT:     `-OMPParallelDirective {{.*}} <line:4:9, col:21>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3, line:7:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |-CompoundStmt {{.*}} <line:5:3, line:7:3>
-// CHECK-NEXT:           | `-OMPCancellationPointDirective {{.*}} <line:6:9, col:40>
+// CHECK-NEXT:           |-CompoundStmt {{.*}} <line:5:3, line:7:3> openmp_structured_block
+// CHECK-NEXT:           | `-OMPCancellationPointDirective {{.*}} <line:6:9, col:40> openmp_standalone_directive
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-cancellation-point.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-critical.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp critical
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-critical.c:3:1, line:6:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
 // CHECK-NEXT:     `-OMPCriticalDirective {{.*}} <line:4:9, col:21>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT:           |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:           |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-critical.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-distribute-parallel-for-simd.c

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-distribute-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-distribute-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT:         | |   |-<<<NULL>>>
 // CHECK-NEXT:         | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | |     |-<<<NULL>>>
 // CHECK-NEXT:         | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-distribute-parallel-for.c

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-distribute-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-distribute-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT:         | |   |-<<<NULL>>>
 // CHECK-NEXT:         | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | |     |-<<<NULL>>>
 // CHECK-NEXT:         | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-distribute-simd.c

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-distribute-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:22, col:26> col:26 used y 'int'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:29, line:14:1>
 // CHECK-NEXT: |   `-OMPDistributeSimdDirective {{.*}} <line:10:9, col:28>
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:11:3, line:13:7>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-ForStmt {{.*}} <line:11:3, line:13:7>
 // CHECK-NEXT: |       | | |-DeclStmt {{.*}} <line:11:8, col:17>
 // CHECK-NEXT: |       | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-distribute-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <line:26:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: `-FunctionDecl {{.*}} <line:30:1, line:36:1> line:30:6 test_five 'void (int, int, int)'

 // CHECK-NEXT:         | |   |-<<<NULL>>>
 // CHECK-NEXT:         | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | |     |-<<<NULL>>>
 // CHECK-NEXT:         | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-distribute.c

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-distribute.c:4:9) *const restrict'
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:22, col:26> col:26 used y 'int'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:29, line:14:1>
 // CHECK-NEXT: |   `-OMPDistributeDirective {{.*}} <line:10:9, col:23>
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:11:3, line:13:7>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK-NEXT: |       | |-ForStmt {{.*}} <line:11:3, line:13:7>
 // CHECK-NEXT: |       | | |-DeclStmt {{.*}} <line:11:8, col:17>
 // CHECK-NEXT: |       | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-distribute.c:24:9) *const restrict'
 // CHECK-NEXT: |       | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr {{.*}} <line:25:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <line:26:5> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: `-FunctionDecl {{.*}} <line:30:1, line:36:1> line:30:6 test_five 'void (int, int, int)'

 // CHECK-NEXT:         | |   |-<<<NULL>>>
 // CHECK-NEXT:         | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | |     |-<<<NULL>>>
 // CHECK-NEXT:         | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-flush.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp flush
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-flush.c:3:1, line:5:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:5:1>
-// CHECK-NEXT:     `-OMPFlushDirective {{.*}} <line:4:9, col:18>
+// CHECK-NEXT:     `-OMPFlushDirective {{.*}} <line:4:9, col:18> openmp_standalone_directive

cfe/trunk/test/AST/ast-dump-openmp-for-simd.c

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:22, col:26> col:26 used y 'int'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:29, line:14:1>
 // CHECK-NEXT: |   `-OMPForSimdDirective {{.*}} <line:10:9, col:21>
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:11:3, line:13:7>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK-NEXT: |       | |-ForStmt {{.*}} <line:11:3, line:13:7>
 // CHECK-NEXT: |       | | |-DeclStmt {{.*}} <line:11:8, col:17>
 // CHECK-NEXT: |       | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <line:26:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: `-FunctionDecl {{.*}} <line:30:1, line:36:1> line:30:6 test_five 'void (int, int, int)'

 // CHECK-NEXT:         | |   |-<<<NULL>>>
 // CHECK-NEXT:         | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | |     |-<<<NULL>>>
 // CHECK-NEXT:         | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-for.c

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator 0x{{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr 0x{{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr 0x{{.*}} <col:19> 'int' lvalue Var 0x{{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr 0x{{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr 0x{{.*}} <col:23> 'int' lvalue ParmVar 0x{{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator 0x{{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr 0x{{.*}} <col:26> 'int' lvalue Var 0x{{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt 0x{{.*}} <line:6:5>
+// CHECK-NEXT: |       | | `-NullStmt 0x{{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl 0x{{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       | `-VarDecl 0x{{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral 0x{{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr 0x{{.*}} <col:3> 'int' lvalue ParmVar 0x{{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl 0x{{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl 0x{{.*}} <col:15, col:19> col:19 used x 'int'
 // CHECK-NEXT: | |-ParmVarDecl 0x{{.*}} <col:22, col:26> col:26 used y 'int'
 // CHECK-NEXT: | `-CompoundStmt 0x{{.*}} <col:29, line:14:1>
 // CHECK-NEXT: |   `-OMPForDirective 0x{{.*}} <line:10:9, col:16>
 // CHECK-NEXT: |     `-CapturedStmt 0x{{.*}} <line:11:3, line:13:7>
 // CHECK-NEXT: |       |-CapturedDecl 0x{{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK-NEXT: |       | |-ForStmt 0x{{.*}} <line:11:3, line:13:7>
 // CHECK-NEXT: |       | | |-DeclStmt 0x{{.*}} <line:11:8, col:17>
 // CHECK-NEXT: |       | | | `-VarDecl 0x{{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   `-IntegerLiteral 0x{{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator 0x{{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr 0x{{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr 0x{{.*}} <col:19> 'int' lvalue Var 0x{{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr 0x{{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr 0x{{.*}} <col:23> 'int' lvalue ParmVar 0x{{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator 0x{{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr 0x{{.*}} <col:26> 'int' lvalue Var 0x{{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt 0x{{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | `-ForStmt 0x{{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt 0x{{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl 0x{{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral 0x{{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator 0x{{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr 0x{{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr 0x{{.*}} <col:21> 'int' lvalue Var 0x{{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr 0x{{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator 0x{{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr 0x{{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr 0x{{.*}} <col:19> 'int' lvalue Var 0x{{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr 0x{{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr 0x{{.*}} <col:23> 'int' lvalue ParmVar 0x{{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator 0x{{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr 0x{{.*}} <col:26> 'int' lvalue Var 0x{{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt 0x{{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | `-ForStmt 0x{{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt 0x{{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl 0x{{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral 0x{{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator 0x{{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr 0x{{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr 0x{{.*}} <col:21> 'int' lvalue Var 0x{{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr 0x{{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator 0x{{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr 0x{{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr 0x{{.*}} <col:21> 'int' lvalue Var 0x{{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr 0x{{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   |   `-DeclRefExpr 0x{{.*}} <col:25> 'int' lvalue ParmVar 0x{{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |   |-UnaryOperator 0x{{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | |   | `-DeclRefExpr 0x{{.*}} <col:28> 'int' lvalue Var 0x{{.*}} 'i' 'int'
-// CHECK-NEXT: |       | |   `-NullStmt 0x{{.*}} <line:27:7>
+// CHECK-NEXT: |       | |   `-NullStmt 0x{{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl 0x{{.*}} <line:24:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       | |-VarDecl 0x{{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | `-IntegerLiteral 0x{{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | `-VarDecl 0x{{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral 0x{{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr 0x{{.*}} <line:25:3> 'int' lvalue ParmVar 0x{{.*}} 'x' 'int'
 // CHECK-NEXT: |       `-DeclRefExpr 0x{{.*}} <line:26:5> 'int' lvalue ParmVar 0x{{.*}} 'y' 'int'
 // CHECK-NEXT: `-FunctionDecl 0x{{.*}} <line:30:1, line:36:1> line:30:6 test_five 'void (int, int, int)'

 // CHECK-NEXT:         | |   |-<<<NULL>>>
 // CHECK-NEXT:         | |   |-BinaryOperator 0x{{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr 0x{{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr 0x{{.*}} <col:21> 'int' lvalue Var 0x{{.*}} 'i' 'int'
 // CHECK-NEXT:         | |   | `-ImplicitCastExpr 0x{{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   |   `-DeclRefExpr 0x{{.*}} <col:25> 'int' lvalue ParmVar 0x{{.*}} 'y' 'int'
 // CHECK-NEXT:         | |   |-UnaryOperator 0x{{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | |   | `-DeclRefExpr 0x{{.*}} <col:28> 'int' lvalue Var 0x{{.*}} 'i' 'int'
-// CHECK-NEXT:         | |   `-ForStmt 0x{{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | |   `-ForStmt 0x{{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | |     |-DeclStmt 0x{{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | |     | `-VarDecl 0x{{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | |     |   `-IntegerLiteral 0x{{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | |     |-<<<NULL>>>
 // CHECK-NEXT:         | |     |-BinaryOperator 0x{{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | |     | |-ImplicitCastExpr 0x{{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |     | | `-DeclRefExpr 0x{{.*}} <col:23> 'int' lvalue Var 0x{{.*}} 'i' 'int'
 // CHECK-NEXT:         | |     | `-ImplicitCastExpr 0x{{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-master.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp master
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-master.c:3:1, line:6:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
 // CHECK-NEXT:     `-OMPMasterDirective {{.*}} <line:4:9, col:19>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT:           |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:           |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-master.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-ordered.c

 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: |-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-ordered.c:3:1, line:6:1> line:3:6 test_one 'void ()'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:17, line:6:1>
 // CHECK-NEXT: |   `-OMPOrderedDirective {{.*}} <line:4:9, col:20>
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT: |       `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT: |         |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT: |         |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT: |         `-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-ordered.c:4:9) *const restrict'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:8:1, line:12:1> line:8:6 test_two 'void (int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:22, line:12:1>
 // CHECK-NEXT: |   `-OMPForDirective {{.*}} <line:9:9, col:24>
 // CHECK-NEXT: |     |-OMPOrderedClause {{.*}} <col:17, col:24>
 // CHECK-NEXT: |     | `-<<<NULL>>>
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:10:3, line:11:5>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK-NEXT: |       | |-ForStmt {{.*}} <line:10:3, line:11:5>
 // CHECK-NEXT: |       | | |-DeclStmt {{.*}} <line:10:8, col:17>
 // CHECK-NEXT: |       | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:11:5>
+// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:11:5> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:9:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-ordered.c:9:9) *const restrict'
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:10:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: `-FunctionDecl {{.*}} <line:14:1, line:19:1> line:14:6 test_three 'void (int)'
 // CHECK-NEXT:   |-ParmVarDecl {{.*}} <col:17, col:21> col:21 used x 'int'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:24, line:19:1>
 // CHECK-NEXT:     `-OMPForDirective {{.*}} <line:15:9, col:27>

 // CHECK-NEXT:         | | |-<<<NULL>>>
 // CHECK-NEXT:         | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT:         | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT:         | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT:         | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | `-CompoundStmt {{.*}} <col:31, line:18:3>
-// CHECK-NEXT:         | |   `-OMPOrderedDirective {{.*}} <line:17:9, col:35>
+// CHECK-NEXT:         | | `-CompoundStmt {{.*}} <col:31, line:18:3> openmp_structured_block
+// CHECK-NEXT:         | |   `-OMPOrderedDirective {{.*}} <line:17:9, col:35> openmp_standalone_directive
 // CHECK-NEXT:         | |     |-OMPDependClause {{.*}} <col:21, <invalid sloc>>
 // CHECK-NEXT:         | |     `-<<<NULL>>>
 // CHECK-NEXT:         | |-ImplicitParamDecl {{.*}} <line:15:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-ordered.c:15:9) *const restrict'
 // CHECK-NEXT:         | `-VarDecl {{.*}} <line:16:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT:         |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT:         `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

cfe/trunk/test/AST/ast-dump-openmp-parallel-for-simd.c

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT:         | |   |-<<<NULL>>>
 // CHECK-NEXT:         | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | |     |-<<<NULL>>>
 // CHECK-NEXT:         | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-parallel-for.c

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr {{.*}} <line:25:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT:         | |   |-<<<NULL>>>
 // CHECK-NEXT:         | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | |     |-<<<NULL>>>
 // CHECK-NEXT:         | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-parallel-master-XFAIL.c

 // CHECK: {{.*}}ast-dump-openmp-parallel-master-XFAIL.c:10:22: warning: extra tokens at the end of '#pragma omp parallel' are ignored
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: |-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-parallel-master-XFAIL.c:3:1, line:6:1> line:3:6 test_zero 'void ()'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:18, line:6:1>
 // CHECK-NEXT: |   `-OMPParallelDirective {{.*}} <line:4:9, col:28>
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT: |       `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |         |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT: |         |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT: |         |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |         |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |         `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-parallel-master-XFAIL.c:4:9) *const restrict'
 // CHECK-NEXT: `-FunctionDecl {{.*}} <line:9:1, line:12:1> line:9:6 test_one 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:12:1>
 // CHECK-NEXT:     `-OMPParallelDirective {{.*}} <line:10:9, col:28>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:11:3, col:7>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |-CompoundStmt {{.*}} <col:3, col:7>
+// CHECK-NEXT:           |-CompoundStmt {{.*}} <col:3, col:7> openmp_structured_block
 // CHECK-NEXT:           | `-NullStmt {{.*}} <col:5>
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <line:10:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-parallel-master-XFAIL.c:10:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-parallel-sections.c

 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: |-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-parallel-sections.c:3:1, line:6:1> line:3:6 test_zero 'void ()'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:18, line:6:1>
 // CHECK-NEXT: `-FunctionDecl {{.*}} <line:8:1, line:11:1> line:8:6 test_one 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:11:1>
 // CHECK-NEXT:     `-OMPParallelSectionsDirective {{.*}} <line:9:9, col:30>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:10:3, col:7>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT:           |-CompoundStmt {{.*}} <col:3, col:7>
+// CHECK-NEXT:           |-CompoundStmt {{.*}} <col:3, col:7> openmp_structured_block
 // CHECK-NEXT:           | `-NullStmt {{.*}} <col:5>
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <line:9:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-parallel-sections.c:9:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-parallel.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp parallel
   ;
 }
 
 // CHECK: TranslationUnitDecl 0x{{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl 0x{{.*}} <{{.*}}ast-dump-openmp-parallel.c:3:1, line:6:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt 0x{{.*}} <col:13, line:6:1>
 // CHECK-NEXT:     `-OMPParallelDirective 0x{{.*}} <line:4:9, col:21>
 // CHECK-NEXT:       `-CapturedStmt 0x{{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl 0x{{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |-NullStmt 0x{{.*}} <col:3>
+// CHECK-NEXT:           |-NullStmt 0x{{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:           |-ImplicitParamDecl 0x{{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl 0x{{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:           `-ImplicitParamDecl 0x{{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-parallel.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-section.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp sections
   {
 #pragma omp section
     ;
   }
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-section.c:3:1, line:9:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:9:1>
 // CHECK-NEXT:     `-OMPSectionsDirective {{.*}} <line:4:9, col:21>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3, line:8:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT:           |-CompoundStmt {{.*}} <line:5:3, line:8:3>
+// CHECK-NEXT:           |-CompoundStmt {{.*}} <line:5:3, line:8:3> openmp_structured_block
 // CHECK-NEXT:           | `-OMPSectionDirective {{.*}} <line:6:9, col:20>
 // CHECK-NEXT:           |   `-CapturedStmt {{.*}} <line:7:5>
 // CHECK-NEXT:           |     `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT:           |       |-NullStmt {{.*}} <col:5>
+// CHECK-NEXT:           |       |-NullStmt {{.*}} <col:5> openmp_structured_block
 // CHECK-NEXT:           |       `-ImplicitParamDecl {{.*}} <line:6:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-section.c:6:9) *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-section.c:4:9) *const restrict'
 // CHECK-NEXT:           |-RecordDecl {{.*}} <line:6:9> col:9 implicit struct definition
 // CHECK-NEXT:           | `-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:           `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT:             |-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT:             |-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT:             `-ImplicitParamDecl {{.*}} <line:6:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-section.c:6:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-sections.c

 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: |-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-sections.c:3:1, line:6:1> line:3:6 test_zero 'void ()'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:18, line:6:1>
 // CHECK-NEXT: `-FunctionDecl {{.*}} <line:8:1, line:11:1> line:8:6 test_one 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:11:1>
 // CHECK-NEXT:     `-OMPSectionsDirective {{.*}} <line:9:9, col:21>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:10:3, col:7>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT:           |-CompoundStmt {{.*}} <col:3, col:7>
+// CHECK-NEXT:           |-CompoundStmt {{.*}} <col:3, col:7> openmp_structured_block
 // CHECK-NEXT:           | `-NullStmt {{.*}} <col:5>
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <line:9:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-sections.c:9:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-simd.c

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:22, col:26> col:26 used y 'int'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:29, line:14:1>
 // CHECK-NEXT: |   `-OMPSimdDirective {{.*}} <line:10:9, col:17>
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:11:3, line:13:7>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK-NEXT: |       | |-ForStmt {{.*}} <line:11:3, line:13:7>
 // CHECK-NEXT: |       | | |-DeclStmt {{.*}} <line:11:8, col:17>
 // CHECK-NEXT: |       | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <line:26:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: `-FunctionDecl {{.*}} <line:30:1, line:36:1> line:30:6 test_five 'void (int, int, int)'

 // CHECK-NEXT:         | |   |-<<<NULL>>>
 // CHECK-NEXT:         | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | |     |-<<<NULL>>>
 // CHECK-NEXT:         | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-single.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp single
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-single.c:3:1, line:6:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
 // CHECK-NEXT:     `-OMPSingleDirective {{.*}} <line:4:9, col:19>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT:           |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:           |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-single.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-target-data.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test(int x) {
 #pragma omp target data map(x)
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-target-data.c:3:1, line:6:1> line:3:6 test 'void (int)'
 // CHECK-NEXT:   |-ParmVarDecl {{.*}} <col:11, col:15> col:15 used x 'int'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:18, line:6:1>
 // CHECK-NEXT:     `-OMPTargetDataDirective {{.*}} <line:4:9, col:31>
 // CHECK-NEXT:       |-OMPMapClause {{.*}} <col:25, col:30>
 // CHECK-NEXT:       | `-DeclRefExpr {{.*}} <col:29> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT:           |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:           |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-data.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-target-enter-data.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test(int x) {
 #pragma omp target enter data map(to \
                                   : x)
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-target-enter-data.c:3:1, line:6:1> line:3:6 test 'void (int)'
 // CHECK-NEXT:   |-ParmVarDecl {{.*}} <col:11, col:15> col:15 used x 'int'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:18, line:6:1>
-// CHECK-NEXT:     `-OMPTargetEnterDataDirective {{.*}} <line:4:9, line:5:39>
+// CHECK-NEXT:     `-OMPTargetEnterDataDirective {{.*}} <line:4:9, line:5:39> openmp_standalone_directive
 // CHECK-NEXT:       |-OMPMapClause {{.*}} <line:4:31, line:5:38>
 // CHECK-NEXT:       | `-DeclRefExpr {{.*}} <col:37> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:4:9>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:           |-CompoundStmt {{.*}} <col:9>
 // CHECK-NEXT:           |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-enter-data.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-target-exit-data.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test(int x) {
 #pragma omp target exit data map(from \
                                  : x)
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-target-exit-data.c:3:1, line:6:1> line:3:6 test 'void (int)'
 // CHECK-NEXT:   |-ParmVarDecl {{.*}} <col:11, col:15> col:15 used x 'int'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:18, line:6:1>
-// CHECK-NEXT:     `-OMPTargetExitDataDirective {{.*}} <line:4:9, line:5:38>
+// CHECK-NEXT:     `-OMPTargetExitDataDirective {{.*}} <line:4:9, line:5:38> openmp_standalone_directive
 // CHECK-NEXT:       |-OMPMapClause {{.*}} <line:4:30, line:5:37>
 // CHECK-NEXT:       | `-DeclRefExpr {{.*}} <col:36> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:4:9>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:           |-CompoundStmt {{.*}} <col:9>
 // CHECK-NEXT:           |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-exit-data.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-target-parallel-for-simd.c

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | | | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | | | `-FieldDecl {{.*}} <line:5:23> col:23 implicit 'int'
 // CHECK-NEXT: |       | | | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | |   |-ForStmt {{.*}} <col:3, line:6:5>
 // CHECK-NEXT: |       | | |   | |-DeclStmt {{.*}} <line:5:8, col:17>
 // CHECK-NEXT: |       | | |   | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | |   | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | |   `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int'

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |   | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       |   | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       |   | `-FieldDecl {{.*}} <line:5:23> col:23 implicit 'int'
 // CHECK-NEXT: |       |   |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       |   `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |     |-ForStmt {{.*}} <col:3, line:6:5>
 // CHECK-NEXT: |       |     | |-DeclStmt {{.*}} <line:5:8, col:17>
 // CHECK-NEXT: |       |     | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |     | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |     `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |       `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |     |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |     |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | | | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | | | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | |   |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | |   |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |     `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |   | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       |   | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |     |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       |     |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |       `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT:         | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | | | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |   |   |-<<<NULL>>>
 // CHECK-NEXT:         | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | |   |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | |   |     |-<<<NULL>>>
 // CHECK-NEXT:         | | |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |   | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |   | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |     |   |-<<<NULL>>>
 // CHECK-NEXT:         |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |     |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |     |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |     |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |     |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |     |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |     |     |-<<<NULL>>>
 // CHECK-NEXT:         |     |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |     |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-target-parallel-for.c

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | | | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | | | `-FieldDecl {{.*}} <line:5:3> col:3 implicit 'int'
 // CHECK-NEXT: |       | | | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | |   |-ForStmt {{.*}} <col:3, line:6:5>
 // CHECK-NEXT: |       | | |   | |-DeclStmt {{.*}} <line:5:8, col:17>
 // CHECK-NEXT: |       | | |   | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | |   | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | |   `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int'

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |   | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       |   | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       |   | `-FieldDecl {{.*}} <line:5:3> col:3 implicit 'int'
 // CHECK-NEXT: |       |   |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       |   `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |     |-ForStmt {{.*}} <col:3, line:6:5>
 // CHECK-NEXT: |       |     | |-DeclStmt {{.*}} <line:5:8, col:17>
 // CHECK-NEXT: |       |     | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |     | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       |     `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |       `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |     |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |     |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | | | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | | | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |-DeclRefExpr {{.*}} <line:25:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | |   |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | |   |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |     `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |-DeclRefExpr {{.*}} <line:25:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |   | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       |   | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |-DeclRefExpr {{.*}} <line:25:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |     |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       |     |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |       `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr {{.*}} <line:25:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT:         | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | | | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |   |   |-<<<NULL>>>
 // CHECK-NEXT:         | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | |   |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | |   |     |-<<<NULL>>>
 // CHECK-NEXT:         | | |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |   | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |   | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |     |   |-<<<NULL>>>
 // CHECK-NEXT:         |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |     |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |     |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |     |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |     |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |     |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |     |     |-<<<NULL>>>
 // CHECK-NEXT:         |     |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |     |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-target-parallel.c

 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
 // CHECK-NEXT:     `-OMPTargetParallelDirective {{.*}} <line:4:9, col:28>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:           |-CapturedStmt {{.*}} <col:3>
 // CHECK-NEXT:           | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:           |   |-CapturedStmt {{.*}} <col:3>
 // CHECK-NEXT:           |   | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |   |   |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:           |   |   |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:           |   |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:           |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:           |   |   `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel.c:4:9) *const restrict'
 // CHECK-NEXT:           |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel.c:4:9) *const restrict'
 // CHECK-NEXT:           |   |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT:           |   | `-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:           |   `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |     |-NullStmt {{.*}} <line:5:3>
+// CHECK-NEXT:           |     |-NullStmt {{.*}} <line:5:3> openmp_structured_block
 // CHECK-NEXT:           |     |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:           |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:           |     `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel.c:4:9) *const restrict'
 // CHECK-NEXT:           |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel.c:4:9) *const restrict'
 // CHECK-NEXT:           |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT:           | `-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:           `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:             |-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:             | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:             |   |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:             |   |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:             |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:             |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:             |   `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel.c:4:9) *const restrict'
 // CHECK-NEXT:             |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel.c:4:9) *const restrict'
 // CHECK-NEXT:             |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT:             | `-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:             `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:               |-NullStmt {{.*}} <line:5:3>
+// CHECK-NEXT:               |-NullStmt {{.*}} <line:5:3> openmp_structured_block
 // CHECK-NEXT:               |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:               |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:               `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-parallel.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-target-simd.c

 // CHECK-NEXT: |       | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'

 // CHECK-NEXT: |       |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |   | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:22, col:26> col:26 used y 'int'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:29, line:14:1>

 // CHECK-NEXT: |       | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |   | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |   | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | `-DeclRefExpr {{.*}} <line:26:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline

 // CHECK-NEXT: |       |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |   |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |   |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       |   |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <line:26:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: `-FunctionDecl {{.*}} <line:30:1, line:36:1> line:30:6 test_five 'void (int, int, int)'

 // CHECK-NEXT:         | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   |   |-<<<NULL>>>
 // CHECK-NEXT:         |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |   |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |   |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   |     |-<<<NULL>>>
 // CHECK-NEXT:         |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-target-teams-distribute-parallel-for-simd.c

 // CHECK-NEXT: |       | | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | | | | | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | | | | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | |   | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | | | |   | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | | |   `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | |   | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | |   | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | |     | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |     | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | |     | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | |     `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |       `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |   | | | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   | | | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | |   | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |   | |   | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   | |   `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |     | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |     | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |     | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |       | |-<<<NULL>>>
 // CHECK-NEXT: |       |       | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |       | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |       | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |       | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |       | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |       | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |       `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |         `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |     | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |     | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | |     | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | |     |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |   | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |   | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | |   | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |   | |   | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |   | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |     | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |     | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |     | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |       | |-<<<NULL>>>
 // CHECK-NEXT: |       |       | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |       | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |       | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |       | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |       | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |       | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |       |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |       |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |       |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |       |   |-<<<NULL>>>
 // CHECK-NEXT: |       |       |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |       |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |     | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |     | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | |     | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | |     |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |   | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |   | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | |   | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |   | |   | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |   | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |     | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |     | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |     | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |       | |-<<<NULL>>>
 // CHECK-NEXT: |       |       | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |       | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |       | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |       | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |       | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |       | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |       |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |       |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |       |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |       |   |-<<<NULL>>>
 // CHECK-NEXT: |       |       |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |       |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | | | | | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | | | | | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | |   |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | | | |   |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | | | |   |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | |   `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | |   | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | |   | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |     |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | |     |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | |     |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |     | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |     `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |   | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |   | | | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       |   | | | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |   | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | |   |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |   | |   |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       |   | |   |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | |   `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |     | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |     | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |     | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       |     | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |       |   |-<<<NULL>>>
 // CHECK-NEXT: |       |       |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |       |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |       |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |       |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |       |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |       |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       |       |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |       | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |       `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT:         | | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | | | | | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | | | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | | | |   |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | | | |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | |   |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |   | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | |   | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | |   | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | |   | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | |   | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | |   | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | |   | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |     |   |-<<<NULL>>>
 // CHECK-NEXT:         | | |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | |     |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | |     |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | |     |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | |     |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | |     |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | |     |     |-<<<NULL>>>
 // CHECK-NEXT:         | | |     |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | |     |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |     |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |     |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |   | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |   | | | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |   | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | |   |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |   | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |   | |   |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |   | |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | |   |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |     | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |     | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |     | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |     | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |     | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |     | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |     | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |     | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |     | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |     | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |     | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |     | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |     | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |       |   |-<<<NULL>>>
 // CHECK-NEXT:         |       |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |       |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |       |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |       |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |       |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |       |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |       |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |       |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |       |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |       |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |       |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |       |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |       |     |-<<<NULL>>>
 // CHECK-NEXT:         |       |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |       |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |       |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |       |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-target-teams-distribute-parallel-for.c

 // CHECK-NEXT: |       | | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | | | | | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | | | | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | |   | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | | | |   | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | | |   `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | |   | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | |   | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | |     | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |     | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | |     | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | |     `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |       `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |   | | | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   | | | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | |   | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |   | |   | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   | |   `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |     | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |     | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       |     | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |       | |-<<<NULL>>>
 // CHECK-NEXT: |       |       | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |       | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |       | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |       | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |       | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |       | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       |       `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |         `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |     | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |     | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | |     | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | |     |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |   | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |   | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | |   | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |   | |   | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |   | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |     | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |     | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |     | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |       | |-<<<NULL>>>
 // CHECK-NEXT: |       |       | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |       | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |       | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |       | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |       | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |       | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |       |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |       |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |       |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |       |   |-<<<NULL>>>
 // CHECK-NEXT: |       |       |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |       |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |     | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |     | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | |     | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | |     |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |   | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |   | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | |   | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |   | |   | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |   | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |     | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |     | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |     | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |       | |-<<<NULL>>>
 // CHECK-NEXT: |       |       | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |       | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |       | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |       | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |       | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |       | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |       |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |       |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |       |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |       |   |-<<<NULL>>>
 // CHECK-NEXT: |       |       |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |       |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | | | | | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | | | | | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | |   |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | | | |   |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | | | |   |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | |   `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | |   | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | |   | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |     |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | |     |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | |     |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |     | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |     `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |   | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |   | | | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       |   | | | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |   | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | |   |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |   | |   |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       |   | |   |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | |   `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |     | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |     | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |     | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |     | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       |     | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |       |   |-<<<NULL>>>
 // CHECK-NEXT: |       |       |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |       |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |       |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |       |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |       |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |       |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |       |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |       |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |       |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-parallel-for.c:24:9) *const restrict'
 // CHECK-NEXT: |       |       |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |       | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |       `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT:         | | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | | | | | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | | | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | | | |   |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | | | |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | |   |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |   | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | |   | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | |   | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | |   | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | |   | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | |   | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | |   | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |     |   |-<<<NULL>>>
 // CHECK-NEXT:         | | |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | |     |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | |     |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | |     |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | |     |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | |     |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | |     |     |-<<<NULL>>>
 // CHECK-NEXT:         | | |     |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | |     |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |     |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |     |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |   | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |   | | | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |   | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | |   |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |   | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |   | |   |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |   | |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | |   |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |     | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |     | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |     | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |     | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |     | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |     | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |     | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |     | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |     | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |     | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |     | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |     | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |     | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |       |   |-<<<NULL>>>
 // CHECK-NEXT:         |       |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |       |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |       |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |       |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |       |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |       |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |       |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |       |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |       |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |       |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |       |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |       |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |       |     |-<<<NULL>>>
 // CHECK-NEXT:         |       |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |       |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |       |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |       |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-target-teams-distribute-simd.c

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | | | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | | | `-FieldDecl {{.*}} <line:5:23> col:23 implicit 'int'
 // CHECK-NEXT: |       | | | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | |   |-ForStmt {{.*}} <col:3, line:6:5>
 // CHECK-NEXT: |       | | |   | |-DeclStmt {{.*}} <line:5:8, col:17>
 // CHECK-NEXT: |       | | |   | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | |   | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | |   `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int'

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |   | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       |   | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       |   | `-FieldDecl {{.*}} <line:5:23> col:23 implicit 'int'
 // CHECK-NEXT: |       |   |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       |   `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |     |-ForStmt {{.*}} <col:3, line:6:5>
 // CHECK-NEXT: |       |     | |-DeclStmt {{.*}} <line:5:8, col:17>
 // CHECK-NEXT: |       |     | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |     | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |     `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |       `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |     |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |     |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | | | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | | | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | |   |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | |   |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |     `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |   | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       |   | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |     |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute-simd.c:24:9) *const restrict'
 // CHECK-NEXT: |       |     |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |       `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr {{.*}} <line:25:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT:         | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | | | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |   |   |-<<<NULL>>>
 // CHECK-NEXT:         | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | |   |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | |   |     |-<<<NULL>>>
 // CHECK-NEXT:         | | |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |   | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |   | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |     |   |-<<<NULL>>>
 // CHECK-NEXT:         |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |     |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |     |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |     |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |     |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |     |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |     |     |-<<<NULL>>>
 // CHECK-NEXT:         |     |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |     |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-target-teams-distribute.c

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | | | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | | | `-FieldDecl {{.*}} <line:5:3> col:3 implicit 'int'
 // CHECK-NEXT: |       | | | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | |   |-ForStmt {{.*}} <col:3, line:6:5>
 // CHECK-NEXT: |       | | |   | |-DeclStmt {{.*}} <line:5:8, col:17>
 // CHECK-NEXT: |       | | |   | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | |   | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | |   `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int'

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |   | | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   | | `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       |   | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       |   | `-FieldDecl {{.*}} <line:5:3> col:3 implicit 'int'
 // CHECK-NEXT: |       |   |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       |   `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |     |-ForStmt {{.*}} <col:3, line:6:5>
 // CHECK-NEXT: |       |     | |-DeclStmt {{.*}} <line:5:8, col:17>
 // CHECK-NEXT: |       |     | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       |     | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute.c:4:9) *const restrict'
 // CHECK-NEXT: |       |     `-VarDecl {{.*}} <line:5:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |       `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:9:1, line:14:1> line:9:6 test_two 'void (int, int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       |     |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | | | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | |   | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |   | | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |   | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |     | |-<<<NULL>>>
 // CHECK-NEXT: |       |     | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |     | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |     | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |     | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       |     | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       |     |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       |     |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |     |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | | | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | | | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |-DeclRefExpr {{.*}} <line:25:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | |   |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | | |   |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute.c:24:9) *const restrict'
 // CHECK-NEXT: |       | | |   |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | |   `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | |     `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | |-DeclRefExpr {{.*}} <line:25:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |   | | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute.c:24:9) *const restrict'
 // CHECK-NEXT: |       |   | | |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |-DeclRefExpr {{.*}} <line:25:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |     |   |-<<<NULL>>>
 // CHECK-NEXT: |       |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |     |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       |     |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams-distribute.c:24:9) *const restrict'
 // CHECK-NEXT: |       |     |-VarDecl {{.*}} <line:25:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |     | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |     `-VarDecl {{.*}} <line:26:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |       `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |-DeclRefExpr {{.*}} <line:25:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT:         | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | | | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | | | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |   |   |-<<<NULL>>>
 // CHECK-NEXT:         | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | | |   |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | | |   |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | | |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | |   |     |-<<<NULL>>>
 // CHECK-NEXT:         | | |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |   | | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |   | | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |   | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |     |   |-<<<NULL>>>
 // CHECK-NEXT:         |     |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |     |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |     |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |     |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |     |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         |     |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         |     |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         |     |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |     |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |     |     |-<<<NULL>>>
 // CHECK-NEXT:         |     |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |     |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |     |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |     |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-target-teams.c

 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
 // CHECK-NEXT:     `-OMPTargetTeamsDirective {{.*}} <line:4:9, col:25>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:           |-CapturedStmt {{.*}} <col:3>
 // CHECK-NEXT:           | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:           |   |-CapturedStmt {{.*}} <col:3>
 // CHECK-NEXT:           |   | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |   |   |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:           |   |   |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:           |   |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:           |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:           |   |   `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams.c:4:9) *const restrict'
 // CHECK-NEXT:           |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams.c:4:9) *const restrict'
 // CHECK-NEXT:           |   |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT:           |   | `-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:           |   `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |     |-NullStmt {{.*}} <line:5:3>
+// CHECK-NEXT:           |     |-NullStmt {{.*}} <line:5:3> openmp_structured_block
 // CHECK-NEXT:           |     |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:           |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:           |     `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams.c:4:9) *const restrict'
 // CHECK-NEXT:           |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams.c:4:9) *const restrict'
 // CHECK-NEXT:           |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT:           | `-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:           `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:             |-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:             | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:             |   |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:             |   |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:             |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:             |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:             |   `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams.c:4:9) *const restrict'
 // CHECK-NEXT:             |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams.c:4:9) *const restrict'
 // CHECK-NEXT:             |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT:             | `-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:             `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:               |-NullStmt {{.*}} <line:5:3>
+// CHECK-NEXT:               |-NullStmt {{.*}} <line:5:3> openmp_structured_block
 // CHECK-NEXT:               |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:               |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:               `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-teams.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-target-update.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test(int x) {
 #pragma omp target update to(x)
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-target-update.c:3:1, line:5:1> line:3:6 test 'void (int)'
 // CHECK-NEXT:   |-ParmVarDecl {{.*}} <col:11, col:15> col:15 used x 'int'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:18, line:5:1>
-// CHECK-NEXT:     `-OMPTargetUpdateDirective {{.*}} <line:4:9, col:32>
+// CHECK-NEXT:     `-OMPTargetUpdateDirective {{.*}} <line:4:9, col:32> openmp_standalone_directive
 // CHECK-NEXT:       |-OMPToClause {{.*}} <col:27, col:31>
 // CHECK-NEXT:       | `-DeclRefExpr {{.*}} <col:30> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <col:9>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:           |-CompoundStmt {{.*}} <col:9>
 // CHECK-NEXT:           |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target-update.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-target.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp target
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-target.c:3:1, line:6:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
 // CHECK-NEXT:     `-OMPTargetDirective {{.*}} <line:4:9, col:19>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:           |-CapturedStmt {{.*}} <col:3>
 // CHECK-NEXT:           | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |   |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:           |   |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:           |   `-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target.c:4:9) *const restrict'
 // CHECK-NEXT:           |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target.c:4:9) *const restrict'
 // CHECK-NEXT:           |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT:           | `-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:           `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:             |-NullStmt {{.*}} <line:5:3>
+// CHECK-NEXT:             |-NullStmt {{.*}} <line:5:3> openmp_structured_block
 // CHECK-NEXT:             `-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-target.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-task.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp task
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-task.c:3:1, line:6:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
 // CHECK-NEXT:     `-OMPTaskDirective {{.*}} <line:4:9, col:17>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:           |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:           |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-task.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-taskgroup.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp taskgroup
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-taskgroup.c:3:1, line:6:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
 // CHECK-NEXT:     `-OMPTaskgroupDirective {{.*}} <line:4:9, col:22>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK-NEXT:           |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:           |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:           `-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-taskgroup.c:4:9) *const restrict'

cfe/trunk/test/AST/ast-dump-openmp-taskloop-simd.c

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .lb. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .ub. 'const unsigned long'

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .lb. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .ub. 'const unsigned long'

 // CHECK-NEXT:         | |   |-<<<NULL>>>
 // CHECK-NEXT:         | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | |     |-<<<NULL>>>
 // CHECK-NEXT:         | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-taskloop.c

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5>
+// CHECK-NEXT: |       | | `-NullStmt {{.*}} <line:6:5> openmp_structured_block
 // CHECK-NEXT: |       | |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .lb. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .ub. 'const unsigned long'

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:12:5, line:13:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:12:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7>
+// CHECK-NEXT: |       | | `-ForStmt {{.*}} <line:19:5, line:20:7> openmp_structured_block
 // CHECK-NEXT: |       | |   |-DeclStmt {{.*}} <line:19:10, col:19>
 // CHECK-NEXT: |       | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7>
+// CHECK-NEXT: |       | |   `-NullStmt {{.*}} <line:27:7> openmp_structured_block
 // CHECK-NEXT: |       | |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <line:24:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .lb. 'const unsigned long'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .ub. 'const unsigned long'

 // CHECK-NEXT:         | |   |-<<<NULL>>>
 // CHECK-NEXT:         | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9>
+// CHECK-NEXT:         | |   `-ForStmt {{.*}} <line:34:7, line:35:9> openmp_structured_block
 // CHECK-NEXT:         | |     |-DeclStmt {{.*}} <line:34:12, col:21>
 // CHECK-NEXT:         | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | |     |-<<<NULL>>>
 // CHECK-NEXT:         | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-taskwait.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp taskwait
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-taskwait.c:3:1, line:5:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:5:1>
-// CHECK-NEXT:     `-OMPTaskwaitDirective {{.*}} <line:4:9, col:21>
+// CHECK-NEXT:     `-OMPTaskwaitDirective {{.*}} <line:4:9, col:21> openmp_standalone_directive

cfe/trunk/test/AST/ast-dump-openmp-taskyield.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp taskyield
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-taskyield.c:3:1, line:5:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:5:1>
-// CHECK-NEXT:     `-OMPTaskyieldDirective {{.*}} <line:4:9, col:22>
+// CHECK-NEXT:     `-OMPTaskyieldDirective {{.*}} <line:4:9, col:22> openmp_standalone_directive

cfe/trunk/test/AST/ast-dump-openmp-teams-distribute-parallel-for-simd.c

 #pragma omp target
 #pragma omp teams distribute parallel for simd collapse(2)
   for (int i = 0; i < x; i++)
     for (int i = 0; i < y; i++)
       for (int i = 0; i < z; i++)
         ;
 }
 
-// CHECK:TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
+// CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: |-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:3:1, line:8:1> line:3:6 test_one 'void (int)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:22, line:8:1>
 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:4:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:6:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:5:9, col:47>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:47>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <col:9, col:47>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <col:9, col:47> openmp_structured_block
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       | | | |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | | | |-ForStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       | | | |   | | | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | |   | | | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   |   | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | |   |   | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | |   |   `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | | | | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | | | | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | |   | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | |   `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |-OMPCapturedExprDecl {{.*}} <col:23> col:23 implicit used .capture_expr. 'int'

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:6:23> col:23 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <line:5:9, col:47>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <line:5:9, col:47> openmp_structured_block
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       |   |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | | | |-ForStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       |   |   | | | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       |   |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   |   | | | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   |   | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   |   |   | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   |   |   `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   | | | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   | | | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   |   | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   |   `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |-OMPCapturedExprDecl {{.*}} <col:23> col:23 implicit used .capture_expr. 'int'

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:11:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:13:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:14:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:12:9, col:47>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:47>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <col:9, col:47>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <col:9, col:47> openmp_structured_block
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       | | | |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | | | |-ForStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       | | | |   | | | | |-DeclStmt {{.*}} <line:13:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | | | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | | | | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | |   | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:11:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:13:23> col:23 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:14:25> col:25 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <line:12:9, col:47>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <line:12:9, col:47> openmp_structured_block
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       |   |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | | | |-ForStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       |   |   | | | | |-DeclStmt {{.*}} <line:13:8, col:17>
 // CHECK-NEXT: |       |   |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | | | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:19:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:21:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:22:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:20:9, col:59>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:59>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <col:9, col:59>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <col:9, col:59> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-OMPCollapseClause {{.*}} <col:48, col:58>
 // CHECK-NEXT: |       | | | | | `-ConstantExpr {{.*}} <col:57> 'int'
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:57> 'int' 1
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       | | | |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | | | |-ForStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       | | | |   | | | | |-DeclStmt {{.*}} <line:21:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | | | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | | | | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | |   | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:19:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:21:23> col:23 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:22:25> col:25 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <line:20:9, col:59>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <line:20:9, col:59> openmp_structured_block
 // CHECK-NEXT: |       |   | |-OMPCollapseClause {{.*}} <col:48, col:58>
 // CHECK-NEXT: |       |   | | `-ConstantExpr {{.*}} <col:57> 'int'
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:57> 'int' 1
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       |   |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | | | |-ForStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       |   |   | | | | |-DeclStmt {{.*}} <line:21:8, col:17>
 // CHECK-NEXT: |       |   |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | | | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:27:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:29:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:30:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:28:9, col:59>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:59>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <col:9, col:59>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <col:9, col:59> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-OMPCollapseClause {{.*}} <col:48, col:58>
 // CHECK-NEXT: |       | | | | | `-ConstantExpr {{.*}} <col:57> 'int'
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:57> 'int' 2
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       | | | |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | | | |-ForStmt {{.*}} <line:29:3, line:31:7>

 // CHECK-NEXT: |       | | | |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | |   | | | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | |   | | | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | | |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   |   |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | |   |   |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | |   |   |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   |   `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | | | | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | | | | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | |   |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | |   |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:27:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:29:23> col:23 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:30:25> col:25 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <line:28:9, col:59>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <line:28:9, col:59> openmp_structured_block
 // CHECK-NEXT: |       |   | |-OMPCollapseClause {{.*}} <col:48, col:58>
 // CHECK-NEXT: |       |   | | `-ConstantExpr {{.*}} <col:57> 'int'
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:57> 'int' 2
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       |   |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | | | |-ForStmt {{.*}} <line:29:3, line:31:7>

 // CHECK-NEXT: |       |   |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   |   | | | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   |   | | | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |   |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   |   |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   |   |   |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   |   |   |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   |   `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   | | | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   | | | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   |   |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   |   |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT:       |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT:       | |-DeclRefExpr {{.*}} <line:37:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT:       | |-DeclRefExpr {{.*}} <line:38:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:       | `-DeclRefExpr {{.*}} <line:39:27> 'int' lvalue ParmVar {{.*}} 'z' 'int'
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:36:9, col:59>
 // CHECK-NEXT:         |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         | |-CapturedStmt {{.*}} <col:9, col:59>
 // CHECK-NEXT:         | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:         | | | |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <col:9, col:59>
+// CHECK-NEXT:         | | | |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <col:9, col:59> openmp_structured_block
 // CHECK-NEXT:         | | | | |-OMPCollapseClause {{.*}} <col:48, col:58>
 // CHECK-NEXT:         | | | | | `-ConstantExpr {{.*}} <col:57> 'int'
 // CHECK-NEXT:         | | | | |   `-IntegerLiteral {{.*}} <col:57> 'int' 2
 // CHECK-NEXT:         | | | | `-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         | | | |   | |-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         | | | |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         | | | |   | | | |-ForStmt {{.*}} <line:37:3, line:40:9>

 // CHECK-NEXT:         | | | |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | |   | | | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | |   | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | |   | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | |   | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | |   | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | | |   |   |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | |   |   |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | |   |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | |   |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | |   |   |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | |   |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | | | | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | |   |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | |   |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | |   |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | |   |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:         | | |-FieldDecl {{.*}} <line:37:23> col:23 implicit 'int'
 // CHECK-NEXT:         | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | | |-FieldDecl {{.*}} <line:38:25> col:25 implicit 'int'
 // CHECK-NEXT:         | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | | `-FieldDecl {{.*}} <line:39:27> col:27 implicit 'int'
 // CHECK-NEXT:         | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:         |   |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <line:36:9, col:59>
+// CHECK-NEXT:         |   |-OMPTeamsDistributeParallelForSimdDirective {{.*}} <line:36:9, col:59> openmp_structured_block
 // CHECK-NEXT:         |   | |-OMPCollapseClause {{.*}} <col:48, col:58>
 // CHECK-NEXT:         |   | | `-ConstantExpr {{.*}} <col:57> 'int'
 // CHECK-NEXT:         |   | |   `-IntegerLiteral {{.*}} <col:57> 'int' 2
 // CHECK-NEXT:         |   | `-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         |   |   | |-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         |   |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         |   |   | | | |-ForStmt {{.*}} <line:37:3, line:40:9>

 // CHECK-NEXT:         |   |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   |   | | | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   |   | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   |   | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   |   | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   |   | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   |   | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   |   |   |   |-<<<NULL>>>
 // CHECK-NEXT:         |   |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   |   |   |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   |   |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   |   |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   |   |   |     |-<<<NULL>>>
 // CHECK-NEXT:         |   |   |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   |   |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   | | | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   |   |   |-<<<NULL>>>
 // CHECK-NEXT:         |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   |   |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   |   |     |-<<<NULL>>>
 // CHECK-NEXT:         |   |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-teams-distribute-parallel-for.c

 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:22, line:8:1>
 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:4:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:6:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:5:9, col:42>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:42>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForDirective {{.*}} <col:9, col:42>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForDirective {{.*}} <col:9, col:42> openmp_structured_block
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       | | | |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | | | |-ForStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       | | | |   | | | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | |   | | | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   |   | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | |   |   | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | |   |   `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | | | | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | | | | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | |   | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | |   `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |-OMPCapturedExprDecl {{.*}} <col:23> col:23 implicit used .capture_expr. 'int'

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:4:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:6:3> col:3 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForDirective {{.*}} <line:5:9, col:42>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForDirective {{.*}} <line:5:9, col:42> openmp_structured_block
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       |   |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | | | |-ForStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       |   |   | | | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       |   |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   |   | | | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   |   | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   |   |   | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   |   |   `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   | | | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   | | | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   |   | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   |   `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |     `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |-OMPCapturedExprDecl {{.*}} <col:23> col:23 implicit used .capture_expr. 'int'

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:11:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:13:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:14:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:12:9, col:42>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:42>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForDirective {{.*}} <col:9, col:42>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForDirective {{.*}} <col:9, col:42> openmp_structured_block
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       | | | |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | | | |-ForStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       | | | |   | | | | |-DeclStmt {{.*}} <line:13:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | | | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | | | | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | |   | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:11:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:13:3> col:3 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:14:25> col:25 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForDirective {{.*}} <line:12:9, col:42>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForDirective {{.*}} <line:12:9, col:42> openmp_structured_block
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       |   |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | | | |-ForStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       |   |   | | | | |-DeclStmt {{.*}} <line:13:8, col:17>
 // CHECK-NEXT: |       |   |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | | | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   | | | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   |   | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:19:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:21:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:22:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:20:9, col:54>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:54>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForDirective {{.*}} <col:9, col:54>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForDirective {{.*}} <col:9, col:54> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-OMPCollapseClause {{.*}} <col:43, col:53>
 // CHECK-NEXT: |       | | | | | `-ConstantExpr {{.*}} <col:52> 'int'
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:52> 'int' 1
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       | | | |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | | | |-ForStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       | | | |   | | | | |-DeclStmt {{.*}} <line:21:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | | | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | | | | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | |   | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | |   | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:19:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:21:3> col:3 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:22:25> col:25 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForDirective {{.*}} <line:20:9, col:54>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForDirective {{.*}} <line:20:9, col:54> openmp_structured_block
 // CHECK-NEXT: |       |   | |-OMPCollapseClause {{.*}} <col:43, col:53>
 // CHECK-NEXT: |       |   | | `-ConstantExpr {{.*}} <col:52> 'int'
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:52> 'int' 1
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       |   |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | | | |-ForStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       |   |   | | | | |-DeclStmt {{.*}} <line:21:8, col:17>
 // CHECK-NEXT: |       |   |   | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | | | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   | | | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   |   | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   |   | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   |   |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:27:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:29:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:30:5> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:28:9, col:54>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:54>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForDirective {{.*}} <col:9, col:54>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeParallelForDirective {{.*}} <col:9, col:54> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-OMPCollapseClause {{.*}} <col:43, col:53>
 // CHECK-NEXT: |       | | | | | `-ConstantExpr {{.*}} <col:52> 'int'
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:52> 'int' 2
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       | | | |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | | | |-ForStmt {{.*}} <line:29:3, line:31:7>

 // CHECK-NEXT: |       | | | |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | |   | | | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | |   | | | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | | |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   |   |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | |   |   |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | |   |   |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   |   `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | | | | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | | | | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | |   |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       | | | |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | |   |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:27:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:29:3> col:3 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:30:5> col:5 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForDirective {{.*}} <line:28:9, col:54>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeParallelForDirective {{.*}} <line:28:9, col:54> openmp_structured_block
 // CHECK-NEXT: |       |   | |-OMPCollapseClause {{.*}} <col:43, col:53>
 // CHECK-NEXT: |       |   | | `-ConstantExpr {{.*}} <col:52> 'int'
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:52> 'int' 2
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       |   |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | | | |-ForStmt {{.*}} <line:29:3, line:31:7>

 // CHECK-NEXT: |       |   |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   |   | | | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   |   | | | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |   |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   |   |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   |   |   |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   |   |   |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   |   `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   | | | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   | | | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT: |       |   |   |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   |   |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.lb. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit used .previous.ub. 'const unsigned long'
 // CHECK-NEXT: |       |   |   |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-parallel-for.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   |   |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit

 // CHECK-NEXT:       |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT:       | |-DeclRefExpr {{.*}} <line:37:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT:       | |-DeclRefExpr {{.*}} <line:38:5> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:       | `-DeclRefExpr {{.*}} <line:39:27> 'int' lvalue ParmVar {{.*}} 'z' 'int'
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:36:9, col:54>
 // CHECK-NEXT:         |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         | |-CapturedStmt {{.*}} <col:9, col:54>
 // CHECK-NEXT:         | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:         | | | |-OMPTeamsDistributeParallelForDirective {{.*}} <col:9, col:54>
+// CHECK-NEXT:         | | | |-OMPTeamsDistributeParallelForDirective {{.*}} <col:9, col:54> openmp_structured_block
 // CHECK-NEXT:         | | | | |-OMPCollapseClause {{.*}} <col:43, col:53>
 // CHECK-NEXT:         | | | | | `-ConstantExpr {{.*}} <col:52> 'int'
 // CHECK-NEXT:         | | | | |   `-IntegerLiteral {{.*}} <col:52> 'int' 2
 // CHECK-NEXT:         | | | | `-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         | | | |   | |-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         | | | |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         | | | |   | | | |-ForStmt {{.*}} <line:37:3, line:40:9>

 // CHECK-NEXT:         | | | |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | |   | | | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | |   | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | |   | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | |   | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | |   | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | | |   |   |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | |   |   |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | |   |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | |   |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | |   |   |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | |   |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | | | | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | | |   |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | |   |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | |   |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | |   |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | |   |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:         | | |-FieldDecl {{.*}} <line:37:3> col:3 implicit 'int'
 // CHECK-NEXT:         | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | | |-FieldDecl {{.*}} <line:38:5> col:5 implicit 'int'
 // CHECK-NEXT:         | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | | `-FieldDecl {{.*}} <line:39:27> col:27 implicit 'int'
 // CHECK-NEXT:         | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:         |   |-OMPTeamsDistributeParallelForDirective {{.*}} <line:36:9, col:54>
+// CHECK-NEXT:         |   |-OMPTeamsDistributeParallelForDirective {{.*}} <line:36:9, col:54> openmp_structured_block
 // CHECK-NEXT:         |   | |-OMPCollapseClause {{.*}} <col:43, col:53>
 // CHECK-NEXT:         |   | | `-ConstantExpr {{.*}} <col:52> 'int'
 // CHECK-NEXT:         |   | |   `-IntegerLiteral {{.*}} <col:52> 'int' 2
 // CHECK-NEXT:         |   | `-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         |   |   | |-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         |   |   | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         |   |   | | | |-ForStmt {{.*}} <line:37:3, line:40:9>

 // CHECK-NEXT:         |   |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   |   | | | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   |   | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   |   | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   |   | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   |   | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   |   | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   |   |   |   |-<<<NULL>>>
 // CHECK-NEXT:         |   |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   |   |   |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   |   |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   |   |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   |   |   |     |-<<<NULL>>>
 // CHECK-NEXT:         |   |   |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   |   |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   | | | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   |   |   |-<<<NULL>>>
 // CHECK-NEXT:         |   |   |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   |   |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   |   |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   |   |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   |   |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   |   |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   |   |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   |   |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   |   |     |-<<<NULL>>>
 // CHECK-NEXT:         |   |   |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   |   |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-teams-distribute-simd.c

 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:22, line:8:1>
 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:4:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:6:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:5:9, col:34>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:34>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeSimdDirective {{.*}} <col:9, col:34>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeSimdDirective {{.*}} <col:9, col:34> openmp_structured_block
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-ForStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       | | | |   | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | |   | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | |   | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | |-RecordDecl {{.*}} <line:5:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | | | `-FieldDecl {{.*}} <line:6:23> col:23 implicit 'int &'
 // CHECK-NEXT: |       | | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | | |-ForStmt {{.*}} <col:3, line:7:5>
 // CHECK-NEXT: |       | | | | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       | | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |-OMPCapturedExprDecl {{.*}} <col:23> col:23 implicit used .capture_expr. 'int'
 // CHECK-NEXT: |       | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:6:23> col:23 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeSimdDirective {{.*}} <line:5:9, col:34>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeSimdDirective {{.*}} <line:5:9, col:34> openmp_structured_block
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-ForStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       |   |   | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   |   | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   |   | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   |-RecordDecl {{.*}} <line:5:9> col:9 implicit struct definition
 // CHECK-NEXT: |       |   | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       |   | `-FieldDecl {{.*}} <line:6:23> col:23 implicit 'int &'
 // CHECK-NEXT: |       |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   | |-ForStmt {{.*}} <col:3, line:7:5>
 // CHECK-NEXT: |       |   | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |-OMPCapturedExprDecl {{.*}} <col:23> col:23 implicit used .capture_expr. 'int'
 // CHECK-NEXT: |       |   | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:11:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:13:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:14:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:12:9, col:34>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:34>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeSimdDirective {{.*}} <col:9, col:34>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeSimdDirective {{.*}} <col:9, col:34> openmp_structured_block
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-ForStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       | | | |   | | |-DeclStmt {{.*}} <line:13:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | |   | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:11:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:13:23> col:23 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:14:25> col:25 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeSimdDirective {{.*}} <line:12:9, col:34>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeSimdDirective {{.*}} <line:12:9, col:34> openmp_structured_block
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-ForStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       |   |   | | |-DeclStmt {{.*}} <line:13:8, col:17>
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   |   | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:19:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:21:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:22:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:20:9, col:46>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:46>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeSimdDirective {{.*}} <col:9, col:46>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeSimdDirective {{.*}} <col:9, col:46> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-OMPCollapseClause {{.*}} <col:35, col:45>
 // CHECK-NEXT: |       | | | | | `-ConstantExpr {{.*}} <col:44> 'int'
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:44> 'int' 1
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-ForStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       | | | |   | | |-DeclStmt {{.*}} <line:21:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | |   | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:19:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:21:23> col:23 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:22:25> col:25 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeSimdDirective {{.*}} <line:20:9, col:46>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeSimdDirective {{.*}} <line:20:9, col:46> openmp_structured_block
 // CHECK-NEXT: |       |   | |-OMPCollapseClause {{.*}} <col:35, col:45>
 // CHECK-NEXT: |       |   | | `-ConstantExpr {{.*}} <col:44> 'int'
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:44> 'int' 1
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-ForStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       |   |   | | |-DeclStmt {{.*}} <line:21:8, col:17>
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   |   | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:27:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:29:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:30:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:28:9, col:46>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:46>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeSimdDirective {{.*}} <col:9, col:46>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeSimdDirective {{.*}} <col:9, col:46> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-OMPCollapseClause {{.*}} <col:35, col:45>
 // CHECK-NEXT: |       | | | | | `-ConstantExpr {{.*}} <col:44> 'int'
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:44> 'int' 2
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-ForStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       | | | |   | | |-DeclStmt {{.*}} <line:29:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit

 // CHECK-NEXT: |       | | | |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | |   | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | |   | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |-DeclRefExpr {{.*}} <line:29:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |-OMPCapturedExprDecl {{.*}} <line:29:23> col:23 implicit used .capture_expr. 'int'

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:27:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:29:23> col:23 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:30:25> col:25 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeSimdDirective {{.*}} <line:28:9, col:46>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeSimdDirective {{.*}} <line:28:9, col:46> openmp_structured_block
 // CHECK-NEXT: |       |   | |-OMPCollapseClause {{.*}} <col:35, col:45>
 // CHECK-NEXT: |       |   | | `-ConstantExpr {{.*}} <col:44> 'int'
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:44> 'int' 2
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-ForStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       |   |   | | |-DeclStmt {{.*}} <line:29:8, col:17>
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit

 // CHECK-NEXT: |       |   |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   |   | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   |   | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |-DeclRefExpr {{.*}} <line:29:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute-simd.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |-OMPCapturedExprDecl {{.*}} <line:29:23> col:23 implicit used .capture_expr. 'int'

 // CHECK-NEXT:       |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT:       | |-DeclRefExpr {{.*}} <line:37:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT:       | |-DeclRefExpr {{.*}} <line:38:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:       | `-DeclRefExpr {{.*}} <line:39:27> 'int' lvalue ParmVar {{.*}} 'z' 'int'
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:36:9, col:46>
 // CHECK-NEXT:         |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         | |-CapturedStmt {{.*}} <col:9, col:46>
 // CHECK-NEXT:         | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:         | | | |-OMPTeamsDistributeSimdDirective {{.*}} <col:9, col:46>
+// CHECK-NEXT:         | | | |-OMPTeamsDistributeSimdDirective {{.*}} <col:9, col:46> openmp_structured_block
 // CHECK-NEXT:         | | | | |-OMPCollapseClause {{.*}} <col:35, col:45>
 // CHECK-NEXT:         | | | | | `-ConstantExpr {{.*}} <col:44> 'int'
 // CHECK-NEXT:         | | | | |   `-IntegerLiteral {{.*}} <col:44> 'int' 2
 // CHECK-NEXT:         | | | | `-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         | | | |   | |-ForStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         | | | |   | | |-DeclStmt {{.*}} <line:37:8, col:17>
 // CHECK-NEXT:         | | | |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit

 // CHECK-NEXT:         | | | |   | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | |   | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | |   | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | |   | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | |   | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | |   | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:         | | |-FieldDecl {{.*}} <line:37:23> col:23 implicit 'int'
 // CHECK-NEXT:         | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | | |-FieldDecl {{.*}} <line:38:25> col:25 implicit 'int'
 // CHECK-NEXT:         | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | | `-FieldDecl {{.*}} <line:39:27> col:27 implicit 'int'
 // CHECK-NEXT:         | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:         |   |-OMPTeamsDistributeSimdDirective {{.*}} <line:36:9, col:46>
+// CHECK-NEXT:         |   |-OMPTeamsDistributeSimdDirective {{.*}} <line:36:9, col:46> openmp_structured_block
 // CHECK-NEXT:         |   | |-OMPCollapseClause {{.*}} <col:35, col:45>
 // CHECK-NEXT:         |   | | `-ConstantExpr {{.*}} <col:44> 'int'
 // CHECK-NEXT:         |   | |   `-IntegerLiteral {{.*}} <col:44> 'int' 2
 // CHECK-NEXT:         |   | `-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         |   |   | |-ForStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         |   |   | | |-DeclStmt {{.*}} <line:37:8, col:17>
 // CHECK-NEXT:         |   |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit

 // CHECK-NEXT:         |   |   | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   |   | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   |   | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   |   | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   |   | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   |   | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   |   | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-teams-distribute.c

 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:22, line:8:1>
 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:4:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:6:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:5:9, col:29>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:29>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeDirective {{.*}} <col:9, col:29>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeDirective {{.*}} <col:9, col:29> openmp_structured_block
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-ForStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       | | | |   | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | |   | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | |   | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:4:9) *const restrict'
 // CHECK-NEXT: |       | | | |-RecordDecl {{.*}} <line:5:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | | | `-FieldDecl {{.*}} <line:6:3> col:3 implicit 'int &'
 // CHECK-NEXT: |       | | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | | |-ForStmt {{.*}} <col:3, line:7:5>
 // CHECK-NEXT: |       | | | | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       | | | | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       | | | | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:5:9) *const restrict'
 // CHECK-NEXT: |       | | | | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |-OMPCapturedExprDecl {{.*}} <col:23> col:23 implicit used .capture_expr. 'int'
 // CHECK-NEXT: |       | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:4:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:6:3> col:3 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeDirective {{.*}} <line:5:9, col:29>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeDirective {{.*}} <line:5:9, col:29> openmp_structured_block
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-ForStmt {{.*}} <line:6:3, line:7:5>
 // CHECK-NEXT: |       |   |   | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   |   | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   |   | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   `-DeclRefExpr {{.*}} <col:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:4:9) *const restrict'
 // CHECK-NEXT: |       |   |-RecordDecl {{.*}} <line:5:9> col:9 implicit struct definition
 // CHECK-NEXT: |       |   | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       |   | `-FieldDecl {{.*}} <line:6:3> col:3 implicit 'int &'
 // CHECK-NEXT: |       |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   | |-ForStmt {{.*}} <col:3, line:7:5>
 // CHECK-NEXT: |       |   | | |-DeclStmt {{.*}} <line:6:8, col:17>
 // CHECK-NEXT: |       |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | `-NullStmt {{.*}} <line:7:5>
+// CHECK-NEXT: |       |   | | `-NullStmt {{.*}} <line:7:5> openmp_structured_block
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:5:9) *const restrict'
 // CHECK-NEXT: |       |   | `-VarDecl {{.*}} <line:6:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |-OMPCapturedExprDecl {{.*}} <col:23> col:23 implicit used .capture_expr. 'int'
 // CHECK-NEXT: |       |   | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:11:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:13:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:14:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:12:9, col:29>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:29>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeDirective {{.*}} <col:9, col:29>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeDirective {{.*}} <col:9, col:29> openmp_structured_block
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-ForStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       | | | |   | | |-DeclStmt {{.*}} <line:13:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | |   | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       | | | | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:11:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:13:3> col:3 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:14:25> col:25 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeDirective {{.*}} <line:12:9, col:29>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeDirective {{.*}} <line:12:9, col:29> openmp_structured_block
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-ForStmt {{.*}} <line:13:3, line:15:7>
 // CHECK-NEXT: |       |   |   | | |-DeclStmt {{.*}} <line:13:8, col:17>
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   |   | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | `-ForStmt {{.*}} <line:14:5, line:15:7>
+// CHECK-NEXT: |       |   | | `-ForStmt {{.*}} <line:14:5, line:15:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |-DeclStmt {{.*}} <line:14:10, col:19>
 // CHECK-NEXT: |       |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:19:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:21:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:22:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:20:9, col:41>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:41>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeDirective {{.*}} <col:9, col:41>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeDirective {{.*}} <col:9, col:41> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-OMPCollapseClause {{.*}} <col:30, col:40>
 // CHECK-NEXT: |       | | | | | `-ConstantExpr {{.*}} <col:39> 'int'
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:39> 'int' 1
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-ForStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       | | | |   | | |-DeclStmt {{.*}} <line:21:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | |   | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | | | | | |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       | | | | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       | | | | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       | | | | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       | | | | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:19:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:21:3> col:3 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:22:25> col:25 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeDirective {{.*}} <line:20:9, col:41>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeDirective {{.*}} <line:20:9, col:41> openmp_structured_block
 // CHECK-NEXT: |       |   | |-OMPCollapseClause {{.*}} <col:30, col:40>
 // CHECK-NEXT: |       |   | | `-ConstantExpr {{.*}} <col:39> 'int'
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:39> 'int' 1
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-ForStmt {{.*}} <line:21:3, line:23:7>
 // CHECK-NEXT: |       |   |   | | |-DeclStmt {{.*}} <line:21:8, col:17>
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | |   `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   |   | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |       |   | | |-<<<NULL>>>
 // CHECK-NEXT: |       |   | | |-BinaryOperator {{.*}} <col:19, col:23> 'int' '<'
 // CHECK-NEXT: |       |   | | | |-ImplicitCastExpr {{.*}} <col:19> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | | | `-DeclRefExpr {{.*}} <col:19> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | | | `-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | | |   `-DeclRefExpr {{.*}} <col:23> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |       |   | | |-UnaryOperator {{.*}} <col:26, col:27> 'int' postfix '++'
 // CHECK-NEXT: |       |   | | | `-DeclRefExpr {{.*}} <col:26> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | | `-ForStmt {{.*}} <line:22:5, line:23:7>
+// CHECK-NEXT: |       |   | | `-ForStmt {{.*}} <line:22:5, line:23:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |   |-DeclStmt {{.*}} <line:22:10, col:19>
 // CHECK-NEXT: |       |   | |   | `-VarDecl {{.*}} <col:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>

 // CHECK-NEXT: |   `-OMPTargetDirective {{.*}} <line:27:9, col:19>
 // CHECK-NEXT: |     |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT: |     | |-DeclRefExpr {{.*}} <line:29:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT: |     | `-DeclRefExpr {{.*}} <line:30:5> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:28:9, col:41>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | |-CapturedStmt {{.*}} <col:9, col:41>
 // CHECK-NEXT: |       | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       | | | |-OMPTeamsDistributeDirective {{.*}} <col:9, col:41>
+// CHECK-NEXT: |       | | | |-OMPTeamsDistributeDirective {{.*}} <col:9, col:41> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-OMPCollapseClause {{.*}} <col:30, col:40>
 // CHECK-NEXT: |       | | | | | `-ConstantExpr {{.*}} <col:39> 'int'
 // CHECK-NEXT: |       | | | | |   `-IntegerLiteral {{.*}} <col:39> 'int' 2
 // CHECK-NEXT: |       | | | | `-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       | | | |   | |-ForStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       | | | |   | | |-DeclStmt {{.*}} <line:29:8, col:17>
 // CHECK-NEXT: |       | | | |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit

 // CHECK-NEXT: |       | | | |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | |   | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | |   | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | |   | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | |   | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |   |-DeclRefExpr {{.*}} <line:29:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       | | | | |   |-<<<NULL>>>
 // CHECK-NEXT: |       | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       | | | | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       | | | | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       | | | | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:28:9) *const restrict'
 // CHECK-NEXT: |       | | | | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       | | | | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       | | | | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       | | | |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       | | | |-OMPCapturedExprDecl {{.*}} <line:29:23> col:23 implicit used .capture_expr. 'int'

 // CHECK-NEXT: |       | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:27:9) *const restrict'
 // CHECK-NEXT: |       | |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT: |       | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT: |       | | |-FieldDecl {{.*}} <line:29:3> col:3 implicit 'int'
 // CHECK-NEXT: |       | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | | `-FieldDecl {{.*}} <line:30:5> col:5 implicit 'int'
 // CHECK-NEXT: |       | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT: |       | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT: |       |   |-OMPTeamsDistributeDirective {{.*}} <line:28:9, col:41>
+// CHECK-NEXT: |       |   |-OMPTeamsDistributeDirective {{.*}} <line:28:9, col:41> openmp_structured_block
 // CHECK-NEXT: |       |   | |-OMPCollapseClause {{.*}} <col:30, col:40>
 // CHECK-NEXT: |       |   | | `-ConstantExpr {{.*}} <col:39> 'int'
 // CHECK-NEXT: |       |   | |   `-IntegerLiteral {{.*}} <col:39> 'int' 2
 // CHECK-NEXT: |       |   | `-CapturedStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |       |   |   | |-ForStmt {{.*}} <line:29:3, line:31:7>
 // CHECK-NEXT: |       |   |   | | |-DeclStmt {{.*}} <line:29:8, col:17>
 // CHECK-NEXT: |       |   |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit

 // CHECK-NEXT: |       |   |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   |   | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   |   | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   |   | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   |   | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   |   | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |   |-DeclRefExpr {{.*}} <line:29:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'

 // CHECK-NEXT: |       |   | |   |-<<<NULL>>>
 // CHECK-NEXT: |       |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT: |       |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT: |       |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT: |       |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT: |       |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT: |       |   | |   `-NullStmt {{.*}} <line:31:7>
+// CHECK-NEXT: |       |   | |   `-NullStmt {{.*}} <line:31:7> openmp_structured_block
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <line:28:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT: |       |   | |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams-distribute.c:28:9) *const restrict'
 // CHECK-NEXT: |       |   | |-VarDecl {{.*}} <line:29:8, col:16> col:12 used i 'int' cinit
 // CHECK-NEXT: |       |   | | `-IntegerLiteral {{.*}} <col:16> 'int' 0
 // CHECK-NEXT: |       |   | `-VarDecl {{.*}} <line:30:10, col:18> col:14 used i 'int' cinit
 // CHECK-NEXT: |       |   |   `-IntegerLiteral {{.*}} <col:18> 'int' 0
 // CHECK-NEXT: |       |   |-OMPCapturedExprDecl {{.*}} <line:29:23> col:23 implicit used .capture_expr. 'int'

 // CHECK-NEXT:       |-OMPFirstprivateClause {{.*}} <<invalid sloc>> <implicit>
 // CHECK-NEXT:       | |-DeclRefExpr {{.*}} <line:37:3> 'int' lvalue ParmVar {{.*}} 'x' 'int'
 // CHECK-NEXT:       | |-DeclRefExpr {{.*}} <line:38:5> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:       | `-DeclRefExpr {{.*}} <line:39:27> 'int' lvalue ParmVar {{.*}} 'z' 'int'
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:36:9, col:41>
 // CHECK-NEXT:         |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         | |-CapturedStmt {{.*}} <col:9, col:41>
 // CHECK-NEXT:         | | |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:         | | | |-OMPTeamsDistributeDirective {{.*}} <col:9, col:41>
+// CHECK-NEXT:         | | | |-OMPTeamsDistributeDirective {{.*}} <col:9, col:41> openmp_structured_block
 // CHECK-NEXT:         | | | | |-OMPCollapseClause {{.*}} <col:30, col:40>
 // CHECK-NEXT:         | | | | | `-ConstantExpr {{.*}} <col:39> 'int'
 // CHECK-NEXT:         | | | | |   `-IntegerLiteral {{.*}} <col:39> 'int' 2
 // CHECK-NEXT:         | | | | `-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         | | | |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         | | | |   | |-ForStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         | | | |   | | |-DeclStmt {{.*}} <line:37:8, col:17>
 // CHECK-NEXT:         | | | |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit

 // CHECK-NEXT:         | | | |   | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | |   | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | |   | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | |   | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | |   | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | |   | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | |   | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | |   | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | |   | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | | | |   |-<<<NULL>>>
 // CHECK-NEXT:         | | | | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         | | | | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         | | | | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         | | | | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         | | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         | | | | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         | | | | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         | | | | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         | | | | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         | | | | |     |-<<<NULL>>>
 // CHECK-NEXT:         | | | | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         | | | | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         | | | | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         | | | | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         | | |-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:         | | |-FieldDecl {{.*}} <line:37:3> col:3 implicit 'int'
 // CHECK-NEXT:         | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | | |-FieldDecl {{.*}} <line:38:5> col:5 implicit 'int'
 // CHECK-NEXT:         | | | `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | | `-FieldDecl {{.*}} <line:39:27> col:27 implicit 'int'
 // CHECK-NEXT:         | |   `-OMPCaptureKindAttr {{.*}} <<invalid sloc>> Implicit 9
 // CHECK-NEXT:         | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:         |   |-OMPTeamsDistributeDirective {{.*}} <line:36:9, col:41>
+// CHECK-NEXT:         |   |-OMPTeamsDistributeDirective {{.*}} <line:36:9, col:41> openmp_structured_block
 // CHECK-NEXT:         |   | |-OMPCollapseClause {{.*}} <col:30, col:40>
 // CHECK-NEXT:         |   | | `-ConstantExpr {{.*}} <col:39> 'int'
 // CHECK-NEXT:         |   | |   `-IntegerLiteral {{.*}} <col:39> 'int' 2
 // CHECK-NEXT:         |   | `-CapturedStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         |   |   |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:         |   |   | |-ForStmt {{.*}} <line:37:3, line:40:9>
 // CHECK-NEXT:         |   |   | | |-DeclStmt {{.*}} <line:37:8, col:17>
 // CHECK-NEXT:         |   |   | | | `-VarDecl {{.*}} <col:8, col:16> col:12 used i 'int' cinit

 // CHECK-NEXT:         |   |   | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   |   | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   |   | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   |   | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   |   | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   |   | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   |   | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   |   | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   |   | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

 // CHECK-NEXT:         |   | |   |-<<<NULL>>>
 // CHECK-NEXT:         |   | |   |-BinaryOperator {{.*}} <col:21, col:25> 'int' '<'
 // CHECK-NEXT:         |   | |   | |-ImplicitCastExpr {{.*}} <col:21> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |   | | `-DeclRefExpr {{.*}} <col:21> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | |   | `-ImplicitCastExpr {{.*}} <col:25> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |   |   `-DeclRefExpr {{.*}} <col:25> 'int' lvalue ParmVar {{.*}} 'y' 'int'
 // CHECK-NEXT:         |   | |   |-UnaryOperator {{.*}} <col:28, col:29> 'int' postfix '++'
 // CHECK-NEXT:         |   | |   | `-DeclRefExpr {{.*}} <col:28> 'int' lvalue Var {{.*}} 'i' 'int'
-// CHECK-NEXT:         |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9>
+// CHECK-NEXT:         |   | |   `-ForStmt {{.*}} <line:39:7, line:40:9> openmp_structured_block
 // CHECK-NEXT:         |   | |     |-DeclStmt {{.*}} <line:39:12, col:21>
 // CHECK-NEXT:         |   | |     | `-VarDecl {{.*}} <col:12, col:20> col:16 used i 'int' cinit
 // CHECK-NEXT:         |   | |     |   `-IntegerLiteral {{.*}} <col:20> 'int' 0
 // CHECK-NEXT:         |   | |     |-<<<NULL>>>
 // CHECK-NEXT:         |   | |     |-BinaryOperator {{.*}} <col:23, col:27> 'int' '<'
 // CHECK-NEXT:         |   | |     | |-ImplicitCastExpr {{.*}} <col:23> 'int' <LValueToRValue>
 // CHECK-NEXT:         |   | |     | | `-DeclRefExpr {{.*}} <col:23> 'int' lvalue Var {{.*}} 'i' 'int'
 // CHECK-NEXT:         |   | |     | `-ImplicitCastExpr {{.*}} <col:27> 'int' <LValueToRValue>

cfe/trunk/test/AST/ast-dump-openmp-teams.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 void test() {
 #pragma omp target
 #pragma omp teams
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
 // CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-teams.c:3:1, line:7:1> line:3:6 test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:7:1>
 // CHECK-NEXT:     `-OMPTargetDirective {{.*}} <line:4:9, col:19>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:9, col:18>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT:           |-CapturedStmt {{.*}} <col:9, col:18>
 // CHECK-NEXT:           | `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |   |-OMPTeamsDirective {{.*}} <col:9, col:18>
+// CHECK-NEXT:           |   |-OMPTeamsDirective {{.*}} <col:9, col:18> openmp_structured_block
 // CHECK-NEXT:           |   | `-CapturedStmt {{.*}} <line:6:3>
 // CHECK-NEXT:           |   |   `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |   |     |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:           |   |     |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:           |   |     |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:           |   |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:           |   |     `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams.c:5:9) *const restrict'
 // CHECK-NEXT:           |   |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams.c:4:9) *const restrict'
 // CHECK-NEXT:           |   |-RecordDecl {{.*}} <line:5:9> col:9 implicit struct definition
 // CHECK-NEXT:           |   | `-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:           |   `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:           |     |-NullStmt {{.*}} <line:6:3>
+// CHECK-NEXT:           |     |-NullStmt {{.*}} <line:6:3> openmp_structured_block
 // CHECK-NEXT:           |     |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:           |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:           |     `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams.c:5:9) *const restrict'
 // CHECK-NEXT:           |-AlwaysInlineAttr {{.*}} <<invalid sloc>> Implicit __forceinline
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit .global_tid. 'const int'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .part_id. 'const int *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .privates. 'void *const restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .copy_fn. 'void (*const restrict)(void *const restrict, ...)'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .task_t. 'void *const'
 // CHECK-NEXT:           |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams.c:4:9) *const restrict'
 // CHECK-NEXT:           |-RecordDecl {{.*}} <col:9> col:9 implicit struct definition
 // CHECK-NEXT:           | `-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:           `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:             |-OMPTeamsDirective {{.*}} <line:5:9, col:18>
+// CHECK-NEXT:             |-OMPTeamsDirective {{.*}} <line:5:9, col:18> openmp_structured_block
 // CHECK-NEXT:             | `-CapturedStmt {{.*}} <line:6:3>
 // CHECK-NEXT:             |   `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:             |     |-NullStmt {{.*}} <col:3>
+// CHECK-NEXT:             |     |-NullStmt {{.*}} <col:3> openmp_structured_block
 // CHECK-NEXT:             |     |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:             |     |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:             |     `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams.c:5:9) *const restrict'
 // CHECK-NEXT:             |-ImplicitParamDecl {{.*}} <line:4:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams.c:4:9) *const restrict'
 // CHECK-NEXT:             |-RecordDecl {{.*}} <line:5:9> col:9 implicit struct definition
 // CHECK-NEXT:             | `-CapturedRecordAttr {{.*}} <<invalid sloc>> Implicit
 // CHECK-NEXT:             `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
-// CHECK-NEXT:               |-NullStmt {{.*}} <line:6:3>
+// CHECK-NEXT:               |-NullStmt {{.*}} <line:6:3> openmp_structured_block
 // CHECK-NEXT:               |-ImplicitParamDecl {{.*}} <line:5:9> col:9 implicit .global_tid. 'const int *const restrict'
 // CHECK-NEXT:               |-ImplicitParamDecl {{.*}} <col:9> col:9 implicit .bound_tid. 'const int *const restrict'
 // CHECK-NEXT:               `-ImplicitParamDecl {{.*}} <col:9> col:9 implicit __context 'struct (anonymous at {{.*}}ast-dump-openmp-teams.c:5:9) *const restrict'

cfe/trunk/test/AST/dump.cpp

-// RUN: %clang_cc1 -verify -fopenmp -ast-dump %s | FileCheck %s
-// RUN: %clang_cc1 -verify -fopenmp-simd -ast-dump %s | FileCheck %s
+// RUN: %clang_cc1 -verify -fopenmp -ast-dump %s | FileCheck %s -implicit-check-not=openmp_structured_block
+// RUN: %clang_cc1 -verify -fopenmp-simd -ast-dump %s | FileCheck %s -implicit-check-not=openmp_structured_block
 // expected-no-diagnostics
 
 int ga, gb;
 #pragma omp threadprivate(ga, gb)
 
 // CHECK:      |-OMPThreadPrivateDecl {{.+}} <col:9> col:9
 // CHECK-NEXT: | |-DeclRefExpr {{.+}} <col:27> 'int' lvalue Var {{.+}} 'ga' 'int'
 // CHECK-NEXT: | `-DeclRefExpr {{.+}} <col:31> 'int' lvalue Var {{.+}} 'gb' 'int'

 // CHECK-NEXT: |       | `-MemberExpr {{.+}} <col:58> 'int' lvalue ->b
 // CHECK-NEXT: |       |   `-CXXThisExpr {{.+}} <col:58> 'S *' implicit this
 // CHECK-NEXT: |       |-OMPScheduleClause {{.+}} <col:61, col:79>
 // CHECK-NEXT: |       | `-ImplicitCastExpr {{.+}} <col:78> 'int' <LValueToRValue>
 // CHECK-NEXT: |       |   `-DeclRefExpr {{.+}} <col:78> 'int' lvalue OMPCapturedExpr {{.+}} '.capture_expr.' 'int'
 // CHECK-NEXT: |       `-CapturedStmt {{.+}} <line:[[@LINE-15]]:5, line:[[@LINE-14]]:9>
 // CHECK-NEXT: |         |-CapturedDecl {{.+}} <<invalid sloc>> <invalid sloc> nothrow
 // CHECK-NEXT: |         | |-ForStmt {{.+}} <line:[[@LINE-17]]:5, line:[[@LINE-16]]:9>
-// CHECK:      |         | | `-UnaryOperator {{.+}} <line:[[@LINE-17]]:7, col:9> 'int' lvalue prefix '++'
+// CHECK:      |         | | `-UnaryOperator {{.+}} <line:[[@LINE-17]]:7, col:9> openmp_structured_block 'int' lvalue prefix '++'
 // CHECK-NEXT: |         | |   `-DeclRefExpr {{.+}} <col:9> 'int' lvalue OMPCapturedExpr {{.+}} 'a' 'int &'
 
 #pragma omp declare simd
 #pragma omp declare simd inbranch
 void foo();
 
 // CHECK:        |-FunctionDecl {{.+}} <line:[[@LINE-2]]:1, col:10> col:6 foo 'void ()'
 // CHECK-NEXT:   |-OMPDeclareSimdDeclAttr {{.+}} <line:[[@LINE-4]]:9, col:34> Implicit BS_Inbranch

cfe/trunk/test/PCH/stmt-openmp_structured_block-bit.cpp

+// Test this without pch.
+// RUN: %clang_cc1 -std=c++11 -fopenmp -fsyntax-only -verify %s -ast-dump-all | FileCheck %s -implicit-check-not=openmp_structured_block
+
+// Test with pch. Use '-ast-dump' to force deserialization of function bodies.
+// RUN: %clang_cc1 -std=c++11 -fopenmp -emit-pch -o %t %s
+// RUN: echo "// expected-no-diagnostics" | %clang_cc1 -x c++ -std=c++11 -include-pch %t -fopenmp -fsyntax-only -verify - -ast-dump-all | FileCheck %s -implicit-check-not=openmp_structured_block
+
+void test() {
+#pragma omp parallel
+  ;
+}
+
+// expected-no-diagnostics
+
+// CHECK: TranslationUnitDecl 0x{{.*}} <<invalid sloc>> <invalid sloc>
+// CHECK: `-FunctionDecl 0x{{.*}} <{{.*}}stmt-openmp_structured_block-bit.cpp:8:1, line:11:1> line:8:6 {{(test|imported test)}} 'void ()'
+// CHECK-NEXT:   `-CompoundStmt 0x{{.*}} <col:13, line:11:1>
+// CHECK-NEXT:     `-OMPParallelDirective 0x{{.*}} <line:9:9, col:21>
+// CHECK-NEXT:       `-CapturedStmt 0x{{.*}} <line:10:3>
+// CHECK-NEXT:         `-CapturedDecl 0x{{.*}} <<invalid sloc>> <invalid sloc> {{(nothrow|imported <undeserialized declarations> nothrow)}}
+// CHECK-NEXT:           |-NullStmt 0x{{.*}} <col:3> openmp_structured_block
+// CHECK-NEXT:           |-ImplicitParamDecl 0x{{.*}} <line:9:9> col:9 {{(implicit|imported implicit)}} .global_tid. 'const int *const __restrict'
+// CHECK-NEXT:           |-ImplicitParamDecl 0x{{.*}} <col:9> col:9 {{(implicit|imported implicit)}} .bound_tid. 'const int *const __restrict'
+// CHECK-NEXT:           `-ImplicitParamDecl 0x{{.*}} <col:9> col:9 {{(implicit|imported implicit)}} __context '(anonymous struct at {{.*}}stmt-openmp_structured_block-bit.cpp:9:9) *const __restrict'

cfe/trunk/unittests/AST/ASTPrint.h

+//===- unittests/AST/ASTPrint.h ------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Helpers to simplify testing of printing of AST constructs provided in the/
+// form of the source code.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/ADT/SmallString.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+
+using PolicyAdjusterType =
+    Optional<llvm::function_ref<void(PrintingPolicy &Policy)>>;
+
+static void PrintStmt(raw_ostream &Out, const ASTContext *Context,
+                      const Stmt *S, PolicyAdjusterType PolicyAdjuster) {
+  assert(S != nullptr && "Expected non-null Stmt");
+  PrintingPolicy Policy = Context->getPrintingPolicy();
+  if (PolicyAdjuster)
+    (*PolicyAdjuster)(Policy);
+  S->printPretty(Out, /*Helper*/ nullptr, Policy);
+}
+
+class PrintMatch : public ast_matchers::MatchFinder::MatchCallback {
+  SmallString<1024> Printed;
+  unsigned NumFoundStmts;
+  PolicyAdjusterType PolicyAdjuster;
+
+public:
+  PrintMatch(PolicyAdjusterType PolicyAdjuster)
+      : NumFoundStmts(0), PolicyAdjuster(PolicyAdjuster) {}
+
+  void run(const ast_matchers::MatchFinder::MatchResult &Result) override {
+    const Stmt *S = Result.Nodes.getNodeAs<Stmt>("id");
+    if (!S)
+      return;
+    NumFoundStmts++;
+    if (NumFoundStmts > 1)
+      return;
+
+    llvm::raw_svector_ostream Out(Printed);
+    PrintStmt(Out, Result.Context, S, PolicyAdjuster);
+  }
+
+  StringRef getPrinted() const { return Printed; }
+
+  unsigned getNumFoundStmts() const { return NumFoundStmts; }
+};
+
+template <typename T>
+::testing::AssertionResult
+PrintedStmtMatches(StringRef Code, const std::vector<std::string> &Args,
+                   const T &NodeMatch, StringRef ExpectedPrinted,
+                   PolicyAdjusterType PolicyAdjuster = None) {
+
+  PrintMatch Printer(PolicyAdjuster);
+  ast_matchers::MatchFinder Finder;
+  Finder.addMatcher(NodeMatch, &Printer);
+  std::unique_ptr<tooling::FrontendActionFactory> Factory(
+      tooling::newFrontendActionFactory(&Finder));
+
+  if (!tooling::runToolOnCodeWithArgs(Factory->create(), Code, Args))
+    return testing::AssertionFailure()
+           << "Parsing error in \"" << Code.str() << "\"";
+
+  if (Printer.getNumFoundStmts() == 0)
+    return testing::AssertionFailure() << "Matcher didn't find any statements";
+
+  if (Printer.getNumFoundStmts() > 1)
+    return testing::AssertionFailure()
+           << "Matcher should match only one statement (found "
+           << Printer.getNumFoundStmts() << ")";
+
+  if (Printer.getPrinted() != ExpectedPrinted)
+    return ::testing::AssertionFailure()
+           << "Expected \"" << ExpectedPrinted.str() << "\", got \""
+           << Printer.getPrinted().str() << "\"";
+
+  return ::testing::AssertionSuccess();
+}
+
+} // namespace clang

cfe/trunk/unittests/AST/CMakeLists.txt

add_clang_unittest(ASTTests
   CommentTextTest.cpp
   DataCollectionTest.cpp
   DeclPrinterTest.cpp
   DeclTest.cpp
   EvaluateAsRValueTest.cpp
   ExternalASTSourceTest.cpp
   Language.cpp
   NamedDeclPrinterTest.cpp
+  OMPStructuredBlockTest.cpp
   SourceLocationTest.cpp
   StmtPrinterTest.cpp
   StructuralEquivalenceTest.cpp
   )
 
 target_link_libraries(ASTTests
   PRIVATE
   clangAST
   clangASTMatchers
   clangBasic
   clangFrontend
   clangSerialization
   clangTooling
   )

cfe/trunk/unittests/AST/OMPStructuredBlockTest.cpp

+//===- unittests/AST/OMPStructuredBlockTest.cpp ---------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Fine-grained tests for IsOMPStructuredBlock bit of Stmt.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ASTPrint.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/StmtOpenMP.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/ADT/SmallString.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using namespace clang;
+using namespace ast_matchers;
+using namespace tooling;
+
+namespace {
+
+AST_MATCHER(Stmt, isOMPStructuredBlock) { return Node.isOMPStructuredBlock(); }
+
+const ast_matchers::internal::VariadicDynCastAllOfMatcher<
+    Stmt, OMPExecutableDirective>
+    ompExecutableDirective;
+
+const ast_matchers::internal::VariadicDynCastAllOfMatcher<
+    OMPExecutableDirective, OMPTargetDirective>
+    ompTargetDirective;
+
+StatementMatcher OMPInnermostStructuredBlockMatcher() {
+  return stmt(isOMPStructuredBlock(),
+              unless(hasDescendant(stmt(isOMPStructuredBlock()))))
+      .bind("id");
+}
+
+AST_MATCHER(OMPExecutableDirective, isStandaloneDirective) {
+  return Node.isStandaloneDirective();
+}
+
+StatementMatcher OMPStandaloneDirectiveMatcher() {
+  return stmt(ompExecutableDirective(isStandaloneDirective())).bind("id");
+}
+
+template <typename T>
+::testing::AssertionResult
+PrintedOMPStmtMatches(StringRef Code, const T &NodeMatch,
+                      StringRef ExpectedPrinted,
+                      PolicyAdjusterType PolicyAdjuster = None) {
+  std::vector<std::string> Args = {
+      "-fopenmp",
+  };
+  return PrintedStmtMatches(Code, Args, NodeMatch, ExpectedPrinted,
+                            PolicyAdjuster);
+}
+
+static testing::AssertionResult NoMatches(StringRef Code,
+                                          const StatementMatcher &StmtMatch) {
+  PrintMatch Printer((PolicyAdjusterType()));
+  MatchFinder Finder;
+  Finder.addMatcher(StmtMatch, &Printer);
+  std::unique_ptr<FrontendActionFactory> Factory(
+      newFrontendActionFactory(&Finder));
+  if (!runToolOnCode(Factory->create(), Code))
+    return testing::AssertionFailure()
+           << "Parsing error in \"" << Code.str() << "\"";
+  if (Printer.getNumFoundStmts() == 0)
+    return testing::AssertionSuccess();
+  return testing::AssertionFailure()
+         << "Matcher should match only zero statements (found "
+         << Printer.getNumFoundStmts() << ")";
+}
+
+} // unnamed namespace
+
+TEST(OMPStructuredBlock, TestAtomic) {
+  const char *Source =
+      R"(
+void test(int i) {
+#pragma omp atomic
+++i;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), "++i"));
+}
+
+TEST(OMPStructuredBlock, TestBarrier) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp barrier
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
+                                    "#pragma omp barrier\n"));
+  ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
+}
+
+TEST(OMPStructuredBlock, TestCancel) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp parallel
+{
+    #pragma omp cancel parallel
+}
+})";
+  ASSERT_TRUE(
+      PrintedOMPStmtMatches(Source, OMPInnermostStructuredBlockMatcher(), R"({
+    #pragma omp cancel parallel
+}
+)"));
+  ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
+                                    "#pragma omp cancel parallel\n"));
+}
+
+TEST(OMPStructuredBlock, TestCancellationPoint) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp parallel
+{
+#pragma omp cancellation point parallel
+}
+})";
+  ASSERT_TRUE(
+      PrintedOMPStmtMatches(Source, OMPInnermostStructuredBlockMatcher(), R"({
+    #pragma omp cancellation point parallel
+}
+)"));
+  ASSERT_TRUE(
+      PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
+                            "#pragma omp cancellation point parallel\n"));
+}
+
+TEST(OMPStructuredBlock, TestCritical) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp critical
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+//----------------------------------------------------------------------------//
+// Loop tests
+//----------------------------------------------------------------------------//
+
+class OMPStructuredBlockLoop : public ::testing::TestWithParam<const char *> {};
+
+TEST_P(OMPStructuredBlockLoop, TestDirective0) {
+  const std::string Source =
+      R"(
+void test(int x) {
+#pragma omp )" +
+      std::string(GetParam()) + R"(
+for (int i = 0; i < x; i++)
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST_P(OMPStructuredBlockLoop, TestDirective1) {
+  const std::string Source =
+      R"(
+void test(int x, int y) {
+#pragma omp )" +
+      std::string(GetParam()) + R"(
+for (int i = 0; i < x; i++)
+for (int i = 0; i < y; i++)
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(Source,
+                                    OMPInnermostStructuredBlockMatcher(),
+                                    "for (int i = 0; i < y; i++)\n    ;\n"));
+}
+
+TEST_P(OMPStructuredBlockLoop, TestDirectiveCollapse1) {
+  const std::string Source =
+      R"(
+void test(int x, int y) {
+#pragma omp )" +
+      std::string(GetParam()) + R"( collapse(1)
+for (int i = 0; i < x; i++)
+for (int i = 0; i < y; i++)
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(Source,
+                                    OMPInnermostStructuredBlockMatcher(),
+                                    "for (int i = 0; i < y; i++)\n    ;\n"));
+}
+
+TEST_P(OMPStructuredBlockLoop, TestDirectiveCollapse2) {
+  const std::string Source =
+      R"(
+void test(int x, int y) {
+#pragma omp )" +
+      std::string(GetParam()) + R"( collapse(2)
+for (int i = 0; i < x; i++)
+for (int i = 0; i < y; i++)
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST_P(OMPStructuredBlockLoop, TestDirectiveCollapse22) {
+  const std::string Source =
+      R"(
+void test(int x, int y, int z) {
+#pragma omp )" +
+      std::string(GetParam()) + R"( collapse(2)
+for (int i = 0; i < x; i++)
+for (int i = 0; i < y; i++)
+for (int i = 0; i < z; i++)
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(Source,
+                                    OMPInnermostStructuredBlockMatcher(),
+                                    "for (int i = 0; i < z; i++)\n    ;\n"));
+}
+
+INSTANTIATE_TEST_CASE_P(
+    OMPStructuredBlockLoopDirectives, OMPStructuredBlockLoop,
+    ::testing::Values("simd", "for", "for simd", "parallel for",
+                      "parallel for simd", "target parallel for", "taskloop",
+                      "taskloop simd", "distribute", "distribute parallel for",
+                      "distribute parallel for simd", "distribute simd",
+                      "target parallel for simd", "target simd",
+                      "target\n#pragma omp teams distribute",
+                      "target\n#pragma omp teams distribute simd",
+                      "target\n#pragma omp teams distribute parallel for simd",
+                      "target\n#pragma omp teams distribute parallel for",
+                      "target teams distribute",
+                      "target teams distribute parallel for",
+                      "target teams distribute parallel for simd",
+                      "target teams distribute simd"), );
+
+//----------------------------------------------------------------------------//
+// End Loop tests
+//----------------------------------------------------------------------------//
+
+TEST(OMPStructuredBlock, TestFlush) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp flush
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
+                                    "#pragma omp flush\n"));
+  ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
+}
+
+TEST(OMPStructuredBlock, TestMaster) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp master
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, TestOrdered0) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp ordered
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, TestOrdered1) {
+  const char *Source =
+      R"(
+void test(int x) {
+#pragma omp for ordered
+for (int i = 0; i < x; i++)
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, TestOrdered2) {
+  const char *Source =
+      R"(
+void test(int x) {
+#pragma omp for ordered(1)
+for (int i = 0; i < x; i++) {
+#pragma omp ordered depend(source)
+}
+})";
+  ASSERT_TRUE(
+      PrintedOMPStmtMatches(Source, OMPInnermostStructuredBlockMatcher(),
+                            "{\n    #pragma omp ordered depend(source)\n}\n"));
+  ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
+                                    "#pragma omp ordered depend(source)\n"));
+}
+
+TEST(OMPStructuredBlock, DISABLED_TestParallelMaster0XFAIL) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp parallel master
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, DISABLED_TestParallelMaster1XFAIL) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp parallel master
+{ ; }
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), "{\n    ;\n}\n"));
+}
+
+TEST(OMPStructuredBlock, TestParallelSections) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp parallel sections
+{ ; }
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), "{\n    ;\n}\n"));
+}
+
+TEST(OMPStructuredBlock, TestParallelDirective) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp parallel
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+const ast_matchers::internal::VariadicDynCastAllOfMatcher<
+    OMPExecutableDirective, OMPSectionsDirective>
+    ompSectionsDirective;
+
+const ast_matchers::internal::VariadicDynCastAllOfMatcher<
+    OMPExecutableDirective, OMPSectionDirective>
+    ompSectionDirective;
+
+StatementMatcher OMPSectionsDirectiveMatcher() {
+  return stmt(
+             isOMPStructuredBlock(),
+             hasAncestor(ompExecutableDirective(ompSectionsDirective())),
+             unless(hasAncestor(ompExecutableDirective(ompSectionDirective()))))
+      .bind("id");
+}
+
+TEST(OMPStructuredBlock, TestSectionDirective) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp sections
+{
+#pragma omp section
+;
+}
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPSectionsDirectiveMatcher(),
+                                    "{\n"
+                                    "    #pragma omp section\n"
+                                    "        ;\n"
+                                    "}\n"));
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, TestSections) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp sections
+{ ; }
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), "{\n    ;\n}\n"));
+}
+
+TEST(OMPStructuredBlock, TestSingleDirective) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp single
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, TesTargetDataDirective) {
+  const char *Source =
+      R"(
+void test(int x) {
+#pragma omp target data map(x)
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, TesTargetEnterDataDirective) {
+  const char *Source =
+      R"(
+void test(int x) {
+#pragma omp target enter data map(to : x)
+})";
+  ASSERT_TRUE(
+      PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
+                            "#pragma omp target enter data map(to: x)\n"));
+  ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
+}
+
+TEST(OMPStructuredBlock, TesTargetExitDataDirective) {
+  const char *Source =
+      R"(
+void test(int x) {
+#pragma omp target exit data map(from : x)
+})";
+  ASSERT_TRUE(
+      PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
+                            "#pragma omp target exit data map(from: x)\n"));
+  ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
+}
+
+TEST(OMPStructuredBlock, TestTargetParallelDirective) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp target parallel
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, TestTargetTeams) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp target teams
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, TestTargetUpdateDirective) {
+  const char *Source =
+      R"(
+void test(int x) {
+#pragma omp target update to(x)
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
+                                    "#pragma omp target update to(x)\n"));
+  ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
+}
+
+TEST(OMPStructuredBlock, TestTarget) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp target
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, TestTask) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp task
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, TestTaskgroup) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp taskgroup
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}
+
+TEST(OMPStructuredBlock, TestTaskwaitDirective) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp taskwait
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
+                                    "#pragma omp taskwait\n"));
+  ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
+}
+
+TEST(OMPStructuredBlock, TestTaskyieldDirective) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp taskyield
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(Source, OMPStandaloneDirectiveMatcher(),
+                                    "#pragma omp taskyield\n"));
+  ASSERT_TRUE(NoMatches(Source, OMPInnermostStructuredBlockMatcher()));
+}
+
+TEST(OMPStructuredBlock, TestTeams) {
+  const char *Source =
+      R"(
+void test() {
+#pragma omp target
+#pragma omp teams
+;
+})";
+  ASSERT_TRUE(PrintedOMPStmtMatches(
+      Source, OMPInnermostStructuredBlockMatcher(), ";\n"));
+}

cfe/trunk/unittests/AST/StmtPrinterTest.cpp

 //
 // These tests have a coding convention:
 // * statements to be printed should be contained within a function named 'A'
 //   unless it should have some special name (e.g., 'operator+');
 // * additional helper declarations are 'Z', 'Y', 'X' and so on.
 //
 //===----------------------------------------------------------------------===//
 
+#include "ASTPrint.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/SmallString.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace ast_matchers;
 using namespace tooling;
 
 namespace {
 
-using PolicyAdjusterType =
-    Optional<llvm::function_ref<void(PrintingPolicy &Policy)>>;
-
-void PrintStmt(raw_ostream &Out, const ASTContext *Context, const Stmt *S,
-               PolicyAdjusterType PolicyAdjuster) {
-  assert(S != nullptr && "Expected non-null Stmt");
-  PrintingPolicy Policy = Context->getPrintingPolicy();
-  if (PolicyAdjuster)
-    (*PolicyAdjuster)(Policy);
-  S->printPretty(Out, /*Helper*/ nullptr, Policy);
-}
-
-class PrintMatch : public MatchFinder::MatchCallback {
-  SmallString<1024> Printed;
-  unsigned NumFoundStmts;
-  PolicyAdjusterType PolicyAdjuster;
-
-public:
-  PrintMatch(PolicyAdjusterType PolicyAdjuster)
-      : NumFoundStmts(0), PolicyAdjuster(PolicyAdjuster) {}
-
-  void run(const MatchFinder::MatchResult &Result) override {
-    const Stmt *S = Result.Nodes.getNodeAs<Stmt>("id");
-    if (!S)
-      return;
-    NumFoundStmts++;
-    if (NumFoundStmts > 1)
-      return;
-
-    llvm::raw_svector_ostream Out(Printed);
-    PrintStmt(Out, Result.Context, S, PolicyAdjuster);
-  }
-
-  StringRef getPrinted() const {
-    return Printed;
-  }
-
-  unsigned getNumFoundStmts() const {
-    return NumFoundStmts;
-  }
-};
-
-template <typename T>
-::testing::AssertionResult
-PrintedStmtMatches(StringRef Code, const std::vector<std::string> &Args,
-                   const T &NodeMatch, StringRef ExpectedPrinted,
-                   PolicyAdjusterType PolicyAdjuster = None) {
-
-  PrintMatch Printer(PolicyAdjuster);
-  MatchFinder Finder;
-  Finder.addMatcher(NodeMatch, &Printer);
-  std::unique_ptr<FrontendActionFactory> Factory(
-      newFrontendActionFactory(&Finder));
-
-  if (!runToolOnCodeWithArgs(Factory->create(), Code, Args))
-    return testing::AssertionFailure()
-      << "Parsing error in \"" << Code.str() << "\"";
-
-  if (Printer.getNumFoundStmts() == 0)
-    return testing::AssertionFailure()
-        << "Matcher didn't find any statements";
-
-  if (Printer.getNumFoundStmts() > 1)
-    return testing::AssertionFailure()
-        << "Matcher should match only one statement "
-           "(found " << Printer.getNumFoundStmts() << ")";
-
-  if (Printer.getPrinted() != ExpectedPrinted)
-    return ::testing::AssertionFailure()
-      << "Expected \"" << ExpectedPrinted.str() << "\", "
-         "got \"" << Printer.getPrinted().str() << "\"";
-
-  return ::testing::AssertionSuccess();
-}
-
 enum class StdVer { CXX98, CXX11, CXX14, CXX17, CXX2a };
 
 DeclarationMatcher FunctionBodyMatcher(StringRef ContainingFunction) {
   return functionDecl(hasName(ContainingFunction),
                       has(compoundStmt(has(stmt().bind("id")))));
 }
 
 template <typename T>