MPI-Checker patch for Clang Static Analyzer

[Alexander_Droste]

Summary

This patch adds a static analysis checker to verify the correct usage of the MPI API in C and C++.

3 path-sensitive checks are included:

• Double nonblocking: Double request usage by nonblocking calls without intermediate wait
• Missing wait: Nonblocking call without matching wait.
• Unmatched wait: Waiting for a request that was never used by a nonblocking call

Examples of how to use the checker can be found on: GitHub https://github.com/0ax1/MPI-Checker

[Alexander_Droste]

Thanks for the review!

tools/clang/lib/StaticAnalyzer/Checkers/Checkers.td

524 ↗

(On Diff #34664)

I ran the checker on CombBLAS.
All reports were correct and nothing crashed. -> changed the help text

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Container.h

30 ↗

(On Diff #34664)

I think it would belong to <algorithm>. As this is part of libc++, how shall I proceed?

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

25 ↗

(On Diff #34664)

I originally intended to additionally use warnings but then decided
to mark all reports as error types. I simply forgot to remove the warning
constant from the code.

114 ↗

(On Diff #34664)

Yes, the last user can be in another file.
I'll look into the visitor implementation.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

24 ↗

(On Diff #34664)

I changed the parameter name to PreCallEvent.

32 ↗

(On Diff #34664)

The problem about symbolic regions is rather in collectUsedMemRegions() than
in checkDoubleNonblocking() why the guard is again used in checkWaitUsage().
From my understanding, it is not possible to find out for a symbolic region what element count and subregions (in case of an array) it has. All elements of a request array are supposed to be marked as waited in checkWaitUsage() if the wait function used is MPI_Waitall(). MPI_Waitall() receives an array of requests as an argument, in order to wait for all requests (or rather nonblocking operations) to complete. collectUsedMemRegions() iterates over the array to collect all single requests used. Therefore, the region is cannot be symbolic.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

64 ↗

(On Diff #34664)

I updated the comment.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Utility.h

15 ↗

(On Diff #34664)

Ok, I leave this unmodified for the moment.

tools/clang/test/Analysis/MPIChecker.c

114 ↗

(On Diff #34664)

1. Yes, that's not very common but possible.
2. Does this change involve the use of a BugReporterVisitor?!

You're right, it's very similar.

[Alexander_Droste]

• capitalized bug types
• made "MPI Error" constant a member variable
• removed unused "MPI Warning" constant
• renamed precallevent parameter
• cxx type matching support
• null pointer type matching support
• changed help description text to "Checks MPI code"

[zaks.anna]

It's more user friendly to report this issue at the last point where the request is available rather than the last line of the function.
This looks similar to leak report checking. Is it?

Yes, that's not very common but possible.
Does this change involve the use of a BugReporterVisitor?!

You should register/report the diagnostic at check::DeadSymbols event instead of check:: EndFunction; that way the error will be reported earlier.

You're right, it's very similar.

[Alexander_Droste]

In D12761#248382, @zaks.anna wrote:

It's more user friendly to report this issue at the last point where the request is available rather than the last line of the function.
This looks similar to leak report checking. Is it?

Yes, that's not very common but possible.
Does this change involve the use of a BugReporterVisitor?!

You should register/report the diagnostic at check::DeadSymbols event instead of check:: EndFunction; that way the error will be reported earlier.

You're right, it's very similar.

Sorry, I should have been more precise. The check tests if a request is in use by a nonblocking
call at the end of a function. But the request can still be alive after return. You can think of it as
a pointer for which the memory must be freed in the function it was allocated. But the pointer
can exist in global space outside a function. Multiple functions can use the same request.
So the symbol is not necessarily dead at the end of a function.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

33 ↗

(On Diff #34982)

Is that assumption correct?

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

65 ↗

(On Diff #34982)

The LastUser defines the state of the request and is used in the diagnostic.
As the report will make use of the BugReportVisitor because the LastUser can
be in another file, should I change the state marking to make use of an enum?
Currently the function classifier is used, to check what kind of function
the LastUser is, to obtain the requests state. Would this fail if the LastUser is from another file?

[Alexander_Droste]

Meanwhile, I sketched a BugReportVisitor class for the 'double wait' check called
DoubleWaitVisitor which I modeled as a nested class of MPIBugReporter.
Currently, the retrieval of requests always fails in VisitNode(). (see // This is never reached...)
I'm not sure what's wrong, as I set up the class in the same way as presented in other checkers.
Maybe I overlooked something.

Further, I have some questions about the BugReportVisitor mechanism:

Why does the BugReportVisitor have a Profile() function?

// Why is this pattern used in most BugReporterVisitorImpl subclasses in the Profile() function?
static int X = 0;
ID.AddPointer(&X);

Does the function calling VisitNode() traverse backwards in the graph, as long as nullptr is returned?

[Alexander_Droste]

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

137 ↗

(On Diff #35175)

I figured out what the problem about the request retrieval is:
REGISTER_MAP_WITH_PROGRAMSTATE(RequestMap, const clang::ento::clang::mpi::Request)
The documentation states: "The macro should not be used inside namespaces, or for traits that must
be accessible from more than one translation unit." I think I need some advice here, how to make the
same RequestMap accessible in multiple translation units.

[Alexander_Droste]

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

137 ↗

(On Diff #35175)

How about this:
We could capture the PathDiagnosticLocation of the LastUser in each mpi::Request as a member. The RequestMap could then be local to MPICheckerPathSensitive.cpp and no visitors would be needed. The bug reporter class would then not need to know anything about the request map. The only function I can't find to realise this concept would be something like: Report->addPathDiagnosticLocation().

[zaks.anna]

Sorry, I should have been more precise. The check tests if a request is in use by a nonblocking
call at the end of a function. But the request can still be alive after return. You can think of it as
a pointer for which the memory must be freed in the function it was allocated. But the pointer
can exist in global space outside a function. Multiple functions can use the same request.
So the symbol is not necessarily dead at the end of a function.

Is it the API requirement that the wait is performed in the same function?

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

137 ↗

(On Diff #35175)

Almost all other checkers occupy a single file per checker. This is not much more complicated than the others so you could do the same. This would probably be better for consistency, but I do not have such a strong opinion about it and see why you might want to have separate files.

See TaintManager.h for the example of how to share the program state maps across translation units.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

66 ↗

(On Diff #35175)

Look at the ways the other checkers reference a node that occurred earlier along the symbolic execution path. For example, malloc checker tracks the state of each pointer, which could be "Allocated", "Freed"... When we report a leak, for example, the state would be "Allocated" and the symbol would be dead. The BugReporterVisitor walks up the symbolic path on which the issue occurred and prints an extra note at the place where the node is allocated. It knows at which node the pointer is allocated because that is where the state of the pointer changes from untracked to "Allocated".

[Alexander_Droste]

In D12761#250296, @zaks.anna wrote:

Sorry, I should have been more precise. The check tests if a request is in use by a nonblocking
call at the end of a function. But the request can still be alive after return. You can think of it as
a pointer for which the memory must be freed in the function it was allocated. But the pointer
can exist in global space outside a function. Multiple functions can use the same request.
So the symbol is not necessarily dead at the end of a function.

Is it the API requirement that the wait is performed in the same function?

That's a good catch. It is no API requirement that a nonblocking call is matched by a wait within
the scope of a function. I think for C this would be reasonable but for CPP it is not sufficient,
as the matching could be realised with RAII or lambdas. I will change the check so that
it makes use of the checkDeadSymbols callback.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

137 ↗

(On Diff #35175)

Thanks for pointing out TaintManager.h. I'll try to derive a solution from that.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

66 ↗

(On Diff #35175)

Ok, I will use the same pattern. Thanks for the explanation.

[dcoughlin]

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

34 ↗

(On Diff #35175)

You may be able to use StoreManager::iterBindings(), which iterates over symbolic bindings in the store, to handle symbolic regions. See StackAddrEscapeChecker::checkEndFunction() for an example.

[Alexander_Droste]

• changed RequestMap so that the same is used across translation units
• usage of a BugReporterVisitor in reportMissingWait, reportDoubleWait, reportDoubleNonblocking (reportUnmatchedWait needs no visitor)
• based missingWait check on checkDeadSymbol callback
• doubleWaits & doubleNonblocking errors where the 'same' function uses a request twice (e.g. in a loop) got a specific diagnostic, to make the report easily understandable
• fine grained guard in checkDoubleNonblocking & checkWaitUsage

• generalized variable name retrieval (for memory region)
• handle multidimensional arrays in variable name retrieval (for memory region)

• added/adapted integration tests
• removed some helper functions in MPIBugReporter and Utility
• removed UtilityTest.cpp

---

One thing that is still not perfect, is where the last part of the diagnostic
is presented for missing waits. This does not consistently seem to be the end of the scope
of the request (the point where the symbol dies). I compared this with the malloc checker which has
the same behavior. The last diagnostic seems to be presented after the next statement below the last function,
marked by the BugReportVisitor, using the request/memory. I think it would be nice if the last
part of the diagnostic would be presented at the end of the scope.

[Alexander_Droste]

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

35 ↗

(On Diff #35718)

Thanks for the hint! I tried iterBindings but can't get it to add more functionality.
It seems to me that only TypedRegions are iterable.

[Alexander_Droste]

• dynamic init of MPICheckerPathSensitive in checkDeadSymbols()
• updated RequestMap comment

[zaks.anna]

We gave a talk about building checkers a while back; even though it does not talk about the bug reporter visitors, it might be worth watching if you haven't already seen it.

http://llvm.org/devmtg/2012-11/
Building a Checker in 24 hours

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

68 ↗

(On Diff #35800)

There is no reason to add an empty transition to the graph. Maybe you want to get the predecessor instead?

106 ↗

(On Diff #35800)

generateNonFatalErrorNode will add a transition to the exploded graph, which means that you should only generate it if there is an error and you do not need to call addTransition later in the function.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

67 ↗

(On Diff #35800)

Still it looks like you have several pieces of information in the state that are redundant.. Looks like you've added more now.

For example, why do we need RequestId? Each report will only talk about a single request, is this not the case?

Do you absolutely need to store LastUser and VariableName?

Note that storing in the state is very expensive; on the other hand, we can afford to perform costly analysis on post-processing of an error report. This is why all other checkers store minimal information in the state, usually just a single enum and determine all the other information during the walk over the error path in BugReporterVisitor. The visitor will visit all nodes that you visited while reporting this bug, so it should have access to all the information you need.

[Alexander_Droste]

We gave a talk about building checkers a while back; even though it does not talk about the bug reporter visitors, it might be worth watching if you haven't already seen it.

I have watched it some months ago but I'm sure it is a good idea to revisit the talk. Thanks for the idea!

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

68 ↗

(On Diff #35800)

Yes, that's better!

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

67 ↗

(On Diff #35800)

I need the RequestID to distinct function calls of the same type
and location using the request multiple times along the path.
Like in a loop:

for int i ...
   nonblocking(.., request) // double nonblocking

Do you absolutely need to store LastUser and VariableName?

Absolutely not. :D I will remove the string member.
The variable name retrieval can be delayed to the point where the report is created.

I can also remove the enum, as the state of the request can be derived from the LastUser.
The reason why I added the enum member, is that I was concerned about that the CallEventRef
can be invalid to reference again if the call is inlined from an implementation defined in a header.
As this seems not to be the case, I can remove the redundancy.

This is why all other checkers store minimal information in the state, usually just a single enum and determine all the other information during the walk over the error path in BugReporterVisitor.

Ah, I get it. Until now that seemed a bit overly complicated to me.

[zaks.anna]

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

67 ↗

(On Diff #35800)

I suspect the only thing you need in Request is the enum; everything else can be determined while visiting the path.

This should be in ento namespace not in the clang namespace.

[Alexander_Droste]

Sorry about the delay.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

67 ↗

(On Diff #35800)

I think you're right that the enum is sufficient.
Thus for better diagnostics the source range
of the CallEventRef (LastUser)
should be obtained by the BugReportVisitor.
Is it possible to obtain a CallEventRef based on
a memory region? So conceptually this would mean
to find the last function call (before the error node) using
a specific region.

[Alexander_Droste]

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

67 ↗

(On Diff #35800)

I'll give this pattern a try:

const Stmt *S = nullptr;
ProgramPoint ProgLoc = N->getLocation();
if (Optional<StmtPoint> SP = ProgLoc.getAs<StmtPoint>()) {
  S = SP->getStmt();
}
// if S then S->getSourceRange

Looks like it could work.

[Alexander_Droste]

• reduced the Request class members to single 1 byte sized enum
• implemented VisitNode for RequestNodeVisitor to find previous call event using the request
• tolerate null pointer constants in type checking (any MPI type is accepted as a combination)
• removed double wait check as it turned out that calling a wait on a request that was previously used by a wait is technically valid
• minor improvement for variableName function

[Alexander_Droste]

• simplification of logic related to null pointer buffer (checkBufferTypeMatch)

[Alexander_Droste]

• detect missing waits on global variables
• some cleanup

[Alexander_Droste]

• pass files being part of the diff with relative instead of absolute paths

[Alexander_Droste]

Hi,

I think the points mentioned should be all addressed now.
The only thing left is that some of the more generic functionality
maybe should be moved from MPI-Checker related files to others.
Therefor, I need some advice where to put these functions (if necessary).

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Container.h

31 ↗

(On Diff #38900)

I just found /include/llvm/ADT/STLExtras.h. Wouldn't that be a good fit for the contains() function?

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

107 ↗

(On Diff #38900)

I need addTransition() later to take removed requests into account.

[zaks.anna]

I've been mostly looking at the path sensitive checks. Maybe clang-tidy team would be interested in reviewing the syntactic checks.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Container.h

31 ↗

(On Diff #38900)

This sounds right.
I suggest submitting separate patches to the corresponding components.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

107 ↗

(On Diff #38900)

What you have now, is generating a fork - two successors from the initial predecessor. You need to use the addTransition method that takes a predecessor and pass the ErrorNode there. You should also use the State from that node, not the initial state.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Utility.h

54 ↗

(On Diff #38900)

Since this takes no arguments but MemRegion, seems like it could go on MemRegion. Please, submit this as a separate patch.

[alexfh]

Before I can tell you whether this checker makes sense as a clang-tidy check, can you please explain to me (don't want to deduce this from the code) what specific issues does this check target? Is this limited to a set of AST patterns or is there (or is going to be) some path-based or data flow analysis?

[zaks.anna]

This patch contains a mix of checks, some are path sensitive and some are AST checks. See MPICheckerAST.cpp for the latter.

[alexfh]

The only conclusion I can make is that this patch is huge and very inconvenient to review. I'm fine with moving the AST-based checks to clang-tidy, but I strongly prefer each separate check to go in a separate patch.

[Alexander_Droste]

@anna
Thanks for having a look once more! I will submit these parts as separate patches.

@Alexander
This should be only about the AST-based checks, as Anna takes care of the path-sensitive ones.
I think this is not about moving the checks to clang-tidy because they are not linters but detect
errors. The AST-based functionality is roughly structured as followed:

MPIChecker.cpp : This is the entry point class where checkASTDecl is the only callback for AST-based
checks. There the TranslationUnitVisitor is used which traverses the complete TU passed.
During the traversal each check is executed in the course of the VisitCallExpr callback.
The AST-based checks are implemented in MPICheckerAST.(cpp|h). The TypeVisitor , contained
in TypeVisitor.h, is used as a helper class, in order to detect type properties.

This patch contains 3 AST-based checks (type mismatch, incorrect buffer referencing, invalid argument type)
which are described here in detail (see 3.1 AST-Based Checks) :
https://dl.acm.org/ft_gateway.cfm?id=2833159&ftid=1644251&dwn=1&CFID=566596797&CFTOKEN=98261226

[alexfh]

In D12761#304651, @Alexander_Droste wrote:

@anna
Thanks for having a look once more! I will submit these parts as separate patches.

@Alexander
This should be only about the AST-based checks, as Anna takes care of the path-sensitive ones.
I think this is not about moving the checks to clang-tidy because they are not linters but detect
errors.

Well, many clang-tidy checks have a close to 100% true positive rate and also detect errors of different kinds (as opposed to purely stylistic issues). See http://clang.llvm.org/extra/clang-tidy/checks/misc-undelegated-constructor.html for an example. There's nothing that prevents adding more error-detecting checks to clang-tidy.

I also think, that true power of the static analyzer is the path-based analysis capability, but clang-tidy provides a more convenient way to implement AST- or preprocessor-based checks, so most of the AST-based checks should live there (unless they are generic and high-quality enough to be a compiler diagnostic).

The AST-based functionality is roughly structured as followed:

I'm not an expert in the static analyzer code, so I'm not the one to review even AST-based checks there. However, if you decide to move them to clang-tidy, I'll be happy to review that (I suggest introducing a top-level module for MPI-related checks and putting all relevant AST-based checks there).

MPIChecker.cpp : This is the entry point class where checkASTDecl is the only callback for AST-based
checks. There the TranslationUnitVisitor is used which traverses the complete TU passed.
During the traversal each check is executed in the course of the VisitCallExpr callback.
The AST-based checks are implemented in MPICheckerAST.(cpp|h). The TypeVisitor , contained
in TypeVisitor.h, is used as a helper class, in order to detect type properties.

This patch contains 3 AST-based checks (type mismatch, incorrect buffer referencing, invalid argument type)
which are described here in detail (see 3.1 AST-Based Checks) :
https://dl.acm.org/ft_gateway.cfm?id=2833159&ftid=1644251&dwn=1&CFID=566596797&CFTOKEN=98261226

[Alexander_Droste]

Ah ok, I wasn't aware that clang-tidy is not restricted to checks which verify stylistic issues.
What makes it more convenient to integrate the checks in clang-tidy? Is it how the AST-Matcher
functionality can be accessed?

I'm not an expert in the static analyzer code, so I'm not the one to review even AST-based checks there.

The AST-based checks basically use zero functionality from the static analyzer codebase
except the entry callback and the functionality to generate bug reports.

There's nothing that prevents adding more error-detecting checks to clang-tidy.

Wrt. to the checks being part of this patch I have some concerns:

The first problem I see is that some functionlity is shared between the AST-based
and path-sensitive checks. But I think this should be restricted to the MPIFunctionClassifier class.

Another question I have is how this would affect the usability. At the moment
all detected bugs (AST-based and path-sensitive) appear in a single report,
generated by scan-build. Is there still a way to get the results in a single report
if the checks get moved to clang-tidy?

Would the implementation need to change to AST-Matcher based?
The point about the current implementation is that the AST-based checks
are also already backed by a range of tests defined in
tools/clang/test/Analysis/MPIChecker.cpp.

[alexfh]

In D12761#304823, @Alexander_Droste wrote:

Ah ok, I wasn't aware that clang-tidy is not restricted to checks which verify stylistic issues.
What makes it more convenient to integrate the checks in clang-tidy? Is it how the AST-Matcher
functionality can be accessed?

Yes, less boilerplate code needed to work with AST matchers, powerful clang diagnostic infrastructure is used to report errors, also the add_new_check.py script ;)

I'm not an expert in the static analyzer code, so I'm not the one to review even AST-based checks there.

The AST-based checks basically use zero functionality from the static analyzer codebase
except the entry callback and the functionality to generate bug reports.

Well, that's one of the ways to say that I have little experience and interest in reviewing patches to the static analyzer ;)

There's nothing that prevents adding more error-detecting checks to clang-tidy.

Wrt. to the checks being part of this patch I have some concerns:

The first problem I see is that some functionlity is shared between the AST-based
and path-sensitive checks. But I think this should be restricted to the MPIFunctionClassifier class.

If this class stays in the static analyzer, the clang-tidy check code could probably just depend on the relevant library and use this class?

Another question I have is how this would affect the usability. At the moment
all detected bugs (AST-based and path-sensitive) appear in a single report,
generated by scan-build. Is there still a way to get the results in a single report
if the checks get moved to clang-tidy?

clang-tidy can run static analyzer checks. However, it only supports the plain text output format, which is sub-optimal for representing the results of the path-based checks. So the single report scenario is not easy to implement right now. Gábor Horváth proposed a solution for this a few months ago (PList output for clang-tidy), but a proper implementation of this seemed to require some changes in the clang's diagnostic subsystem.

Would the implementation need to change to AST-Matcher based?

That's not a 100% necessary step (you can always add a matcher for translationUnitDecl() and then traverse the AST using a RecursiveASTVisitor, for example), but this usually results in a more compact and easy to understand code.

The point about the current implementation is that the AST-based checks
are also already backed by a range of tests defined in
tools/clang/test/Analysis/MPIChecker.cpp.

Clang-tidy checks should also be backed by tests ;)

[Alexander_Droste]

Yes, less boilerplate code needed to work with AST matchers, powerful clang diagnostic infrastructure is used to report errors, also the add_new_check.py script ;)

Pretty convincing advertisement line :).

If this class stays in the static analyzer, the clang-tidy check code could probably just depend on the relevant library and use this class?

Sounds straightforward.

That's not a 100% necessary step (you can always add a matcher for translationUnitDecl() and then traverse the AST using a RecursiveASTVisitor, for example), but this usually results in a more compact and easy to understand code.

I guess, in case I need to rewrite the code, I just wanted to know how the AST-Matchers work anyway. :)

Clang-tidy checks should also be backed by tests ;)

I kind of assumed that I need to rewrite the tests if the implementation gets changed.

I'll finish with the path-sensitive checks first and will submit the patch for the AST-based checks to clang-tidy after that.
Thanks for offering a review!

[xazax.hun]

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Utility.h

54 ↗

(On Diff #38900)

A different implementation to achieve this functionality is proposed here: http://reviews.llvm.org/D15924
The proposed implementation is much lighter and has less functionality, it will not print the name of the struct and the index of the array (which might be unknown in most of the cases). Does that implementation works for you? Is that sufficient? Please review it.

[Alexander_Droste]

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

107 ↗

(On Diff #38900)

Isn't this covered by the first case?
If there's an ErrorNode pass it to addTransition() else just update the state regarding removed requests.

[Alexander_Droste]

• removed AST related functionality from patch, as AST-based checks will be integrated into clang tidy
• fix checkMissingWaits()
• moved getVariableName() from patch (currently under review here: http://reviews.llvm.org/D16044)
• moved is_contained() from patch (currently under review here: http://reviews.llvm.org/D16053)

[Alexander_Droste]

• removed files not being part of this patch anymore

[zaks.anna]

Hi Alexander,

Sorry for the delay!

The patch should be rebased from the clang repo; for example, you could run "svn diff" from the clang directory. More comments inline.

tools/clang/lib/StaticAnalyzer/Checkers/Checkers.td

75 ↗

(On Diff #45129)

This should probably go under the 'option' package. What do you think?

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.h

24 ↗

(On Diff #45129)

Should this be clang::ento::mpi? Alternatively, you could place everything into a single file and have it live in anonymous namespace. This would also be more consistent with the existing checkers.

40 ↗

(On Diff #45129)

Looks like some of the AST stuff was deleted and some was kept. Please, either remove all of it or keep all of it in.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

26 ↗

(On Diff #45129)

nit: Please, remove the comments with "----" for consistency.

43 ↗

(On Diff #45129)

I'd stress "path" instead of "sensitive" in the name. Also, this indirection is redundant if you remove the AST checks.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

43 ↗

(On Diff #45129)

You should use 'generateErrorNode' or 'generateNonFatalErrorNode' to generate the node on which the error should be reported. If the error is non-fatal, you'd need to use the generated node below. Specifically, use it's state and pass it as the predecessor when adding a transition.

74 ↗

(On Diff #45129)

This is called in a loop. Should you break once the first error is reported?

Also, as before you should use the CheckerContext API to produce a node on which the error should be reported.

79 ↗

(On Diff #45129)

Don't forget to specify a predecessor here once the code above changes.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.h

87 ↗

(On Diff #45129)

Please, use a name other than 'BugReporter' to avoid confusing it with the BugReporter in the analyzer.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIFunctionClassifier.h

45 ↗

(On Diff #45129)

Some of these classifier functions are not used either..

77 ↗

(On Diff #45129)

MPIPointToCollTypes and MPICollToPointTypes do not seem to be used.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

56 ↗

(On Diff #45129)

Let's add some documentation on why you are not using the standard macro REGISTER_MAP_WITH_PROGRAMSTATE. (Might help to avoid confusion lear on.)

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Utility.cpp

21 ↗

(On Diff #45129)

I'd like to remove the Utility.cpp completely by either making the helper functions static or moving them to other shared components.

40 ↗

(On Diff #45129)

This is unused.

47 ↗

(On Diff #45129)

This is not used..

tools/clang/test/Analysis/MPIChecker.cpp

112 ↗

(On Diff #45129)

This is not testing the extra information provided by bug reporter visitor; you should use "// expected-note {...}"

[Alexander_Droste]

Hi Anna,

thanks for having a look once more!

tools/clang/lib/StaticAnalyzer/Checkers/Checkers.td

75 ↗

(On Diff #45129)

Do you mean the 'optin' package? I could not find an 'option' package in Checkers.td.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.h

24 ↗

(On Diff #45129)

I would prefer to put this into clang::ento::mpi, rather than having everything in a single file.

40 ↗

(On Diff #45129)

Sorry about the inconsistent change. I will remove the AST related
functionality completety from this patch, as it will be part of the clang-tidy patch.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

43 ↗

(On Diff #45129)

If sufficient, I would rename MPICheckerPathSensitive to MPICheckerPath then.
Do you mind the indirection?

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

74 ↗

(On Diff #45129)

I don't think break should be called after the first error is reported. Each memory region
represents a different request, why this should be rated as multiple errors.

79 ↗

(On Diff #45129)

Will do.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.h

87 ↗

(On Diff #45129)

I see, that could be confusing. Maybe renaming the variable to BReporter will do.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIFunctionClassifier.h

45 ↗

(On Diff #45129)

These model distinct MPI function classes. I agree that it would be better to remove the unused ones, in order to keep the interface as narrow as possible.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

56 ↗

(On Diff #45129)

Sure, I can do that.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Utility.cpp

21 ↗

(On Diff #45129)

So where shall we put sourceRange()? It is only used by the BugReporter class.
I could make it a member function of the Reporter class. Or would you prefer this
as a member function of MemRegion?

47 ↗

(On Diff #45129)

These are also leftovers from the AST checks.

tools/clang/test/Analysis/MPIChecker.cpp

112 ↗

(On Diff #45129)

I didn't know about expected-note, thanks!

[zaks.anna]

tools/clang/lib/StaticAnalyzer/Checkers/Checkers.td

75 ↗

(On Diff #45129)

Yes, 'option'. I think it got spell checked.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

43 ↗

(On Diff #45129)

I indirection buying us anything? I think it makes the code more difficult to follow,

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

74 ↗

(On Diff #45129)

You might be right, I am not 100% sure what's more user-friendly.. Presumably the fixes are different in each case? Could you add a test case where multiple errors on the same call site are reported? (Ups can use expected-warning@+1 to report multiple warnings on the same line.)

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Utility.cpp

21 ↗

(On Diff #45129)

I don't see why we should't add it to MemRegion. Let's submit that as a separate patch. (If someone else has a better idea they'll tell us:))

[Alexander_Droste]

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

43 ↗

(On Diff #45129)

I think, I like the entry point class being separated from the class which does the actual checking. But the necessity for dynamicInit() maybe outweighs that. I can collapse the two.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

74 ↗

(On Diff #45129)

This is comparable to calling free on different elements, for which memory was never allocated. So each report informs about a distinct missing nonblocking call. I'll give expected-warning@+1 a try.

[Alexander_Droste]

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

79 ↗

(On Diff #45129)

Changed this to the same ErrorNode/State pattern like in checkMissingWaits.

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIFunctionClassifier.h

45 ↗

(On Diff #45129)

I'd like to keep some of the classes/identifiers that are not used in this patch
but will be in the clang-tidy patch, as discussed with Alexander Kornienko.

tools/clang/test/Analysis/MPIChecker.cpp

112 ↗

(On Diff #45129)

I changed the plain comments to // expected-note{{..}} but all tests using an expected note fail by claiming:

error: 'note' diagnostics expected but not seen:
File .../MPIChecker.cpp Line 112: Request is previously used by nonblocking call here.

Though, running the MPI-Checker on this function, the HTML report contains this exact note
at the expected position. The output is produced at the end of MPIBugReporter::RequestNodeVisitor::VisitNode.

Is there something missing, in order to make this an expected note?

[Alexander_Droste]

• fixed checkUnmatchedWaits (added ErrorNode)
• non fatal error node for double nonblocking
• renamed BugReporter variable to BReporter
• description why custom RequestMap is used
• collapse pathsensitivechecker with mpichecker
• mpi-checker move to optin package
• moved sourceRange() memregion.cpp/h
• remove Utility.cpp/h
• put everything into clang::ento
• remove '––––' from comments
• test case checking for multiple missing nonblocking calls in the same line (// expected-warning-re 1+{{Request {{.*}} has..)
• removed some of the mpi classifications/identifiers

[Alexander_Droste]

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

38 ↗

(On Diff #49023)

The MemRegion sourceRange() patch is not under review yet. I will submit the patch for after http://reviews.llvm.org/D16044 got accepted.

[Alexander_Droste]

• removed commented out line
• removed dashes '–––' from comment in MPIChecker.cpp testfile
• (diff is created with clang as pwd)

[Alexander_Droste]

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

46 ↗

(On Diff #49028)

This should actually be reportDoubleNonblocking(..., ErrorNode); instead of ExplNode, right?

[Alexander_Droste]

• use MPI mock header in integration test file

[zaks.anna]

Some comments inline. I still have to do an overall pass over this checker, but it looks much better than the first version!

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

47 ↗

(On Diff #50526)

Correct, it should be ErrorNode. Moreover, if you do not modify the State and use the state from the predecessor node, which is the case here, you do not need to pass a State to it. You do not need to pass the tag either in his case - a page generated for your checker will be used. By default the CheckerContext will use the state of the predecessor node and that default tag. (If you want to pass your tag, it's fine.)

You do need to pass the state if you modify the state as in the next example.

84 ↗

(On Diff #50526)

Here you do need to pass State.

135 ↗

(On Diff #50526)

I do not think I've seen this code before. If you add new functionality, please submit it in a new commit. Otherwise, there is a high chance it will go unnoticed.

Are there examples of the new warnings it caught?

checkEndAnalysis is rarely used by checkers, so you might not need it here. Specifically, you should be notified by the checkDeadSymbols before a symbol dies even if it dies because it's the end of path.

[Alexander_Droste]

I still have to do an overall pass over this checker, but it looks much better than the first version!

:D

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

47 ↗

(On Diff #50526)

Ah I see, this is covered by the default parameters.

135 ↗

(On Diff #50526)

Yes, I added this at some point after the initial patch, after I realized that the following test case fails:

MPI_Request sendReq1;
void missingWait2() { // Check missing wait for global variable.
  int rank = 0;
  double buf = 0;
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD, &sendReq1);
} // expected-warning{{Request 'sendReq1' has no matching wait.}}

if the checker solely relies on checkDeadSymbols. I just rechecked this behavior by commenting out

BReporter->reportMissingWait(Req.second, Req.first, *NodeIt);

in checkMissingWaitsGlobals and the test still fails then. Are global variables really covered by checkDeadSymbols?

[Alexander_Droste]

• omit superfluous arguments passed to generateNonFatalErrorNode

[Alexander_Droste]

test/Analysis/MPIChecker.cpp

97 ↗

(On Diff #50548)

All the expected-notes still fail, even though the diagnostics are presented in a report.

[zaks.anna]

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

136 ↗

(On Diff #50548)

The analyzer does not do a good job tracking global variables. You might get false positives, specifically, where the variable is released in another translation unit or by calling function that the analyzer does not inline.

[Alexander_Droste]

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

136 ↗

(On Diff #50548)

So shall we remove or keep the function?

[zaks.anna]

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

136 ↗

(On Diff #50548)

I think you will get false positives of the nature I describe above if you keep it. If so, you should remove it. The user experience is much better if you avoid false positives.

[Alexander_Droste]

• remove checkMissingWaitsGlobals to prevent potential false positives

[Alexander_Droste]

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

39 ↗

(On Diff #50548)

sourceRange patch -> http://reviews.llvm.org/D18309

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

136 ↗

(On Diff #50548)

I removed the function.

[zaks.anna]

test/Analysis/MPIChecker.cpp

98 ↗

(On Diff #51179)

Do you see the notes in the report? I think you should pass "-analyzer-output=text" to see the notes.

[zaks.anna]

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

95 ↗

(On Diff #51179)

Would it be possible to identify the "interesting node" by just looking at how the state you track changes. This function will be called when we walk the path upward from the error node. For example, you can notice that in the previous state, the Request did not exist and in this state it is Nonblocking. That would allow you to conclude that between those 2 states a function was called. (This is the trick we use in the other checkers (ex: malloc); it simplifies implementation and makes it more robust - we do not need to pattern match as much.)

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

86 ↗

(On Diff #51179)

Can you add a test cases for this report when there are multiple ReqRegions? Looks like all of the test cases with MPI_Waitall succeed. (I test a case where one of the regions has a match in Waitall and one does not as well as when several/all do not have a match.)

test/Analysis/MPIChecker.cpp

113 ↗

(On Diff #51179)

Are we allowed to call reduce -> wait -> reduce with the same req? If so, let's test for that.

Also, can calls to reduce and wait occur in different functions? If so, we need to test cases where they occur in different functions that are all in the same translation unit - all of the implementations are visible to the analyzer. And also test the cases where we pass the request to a function, whose body is not visible to the analyzer, which is the case when the function is defined in another translation unit.

[Alexander_Droste]

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

95 ↗

(On Diff #51179)

I think this should work but would slightly change the way diagnostics are presented in a specific case. If more than 2 nonblocking calls are using a request in sequence, the expected note (Request is previously used by nonblocking call here.) would not point to the previous but to the first nonblocking call of that sequence. What do you think; should the VisitNode function be changed regardless or should it stay as it is because of this specific case?

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

86 ↗

(On Diff #51179)

Sure, I'll add those tests. The case where none of the requests is matched should be covered by missingNonBlockingMultiple.

test/Analysis/MPIChecker.cpp

98 ↗

(On Diff #51179)

If I pass -analyzer-output=text I see the notes in the report. But adding that flag also produces a lot of 'undesired' output like: Loop condition is true. Entering loop body.

113 ↗

(On Diff #51179)

Are we allowed to call reduce -> wait -> reduce with the same req? If so, let's test for that.

Yes, that's allowed. I'll add a test.

Also, can calls to reduce and wait occur in different functions?

This is also possible.

And also test the cases where we pass the request to a function, whose body is not visible to the analyzer, which is the case when the function is defined in another translation unit.

I would then simply create a new pair of .cpp and .h files in the test folder where I define those functions so that the MPI-Checker tests can use them.

[Alexander_Droste]

• added test that uses wrapper functions around MPI functions
• added test to check behavior in case MPI functions are used in other translation units
• added more MPI_Waitall tests -> missingNonBlockingWaitall*

[Alexander_Droste]

• fix typo

[Alexander_Droste]

• check memory regions for nullptr in checkDoubleNonblocking and checkUnmatchedWaits before they get passed to dyn_cast<ElementRegion>

[zaks.anna]

Alexander,

This patch is in a pretty good shape. I am fine with committing it and iterating with smaller updates in tree if it is more convenient for you.

One task that I would like to very strongly encourage is running this on a lot of code. You will find a lot of issues this way that are hard to discover during code review. Both false positives and crashes.

Thanks!
Anna.

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

96 ↗

(On Diff #52148)

The advantage of using the state is that it will be much more robust to any further changes to the compiler/checker because you will not be pattern matching the AST but instead will be checking the state, which the core reasoning is based on. One example that comes to mind is indirect calls. You will reduce the amount of code here as well, simplifying maintainability. This is the pattern we use in other checkers as well, so there is a remote chance we could introduce a new simplified API that will do the walk for the checker writers.

With respect to your example. Does it come up in practice? Wouldn't you warn on the second nonblocking request anyway? Could you add such an example to the tests? (Would be good in any case. If you leave the code as is, you can point to that example as the motivation.)

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

87 ↗

(On Diff #52148)

This is done, right?

test/Analysis/MPIChecker.cpp

99 ↗

(On Diff #52148)

This are explaining the path on which the problem occurs; the users will see them as well. There should not be a lot of those, you do not have a lot of conditions. Would it be reasonable to change the tests to incorporate those. Other alternative is to have another tests file that tests the notes in that mode.

What do you think?

114 ↗

(On Diff #52148)

I would then simply create a new pair of .cpp and .h files in the test folder
where I define those functions so that the MPI-Checker tests can use them.

You do not have to do that. You could just declare the functions and not define them. It will be equivalent to having the definitions in the other TUs.

[Alexander_Droste]

Hi Anna,

I am fine with committing it and iterating with smaller updates in tree if it is more convenient for you.

This sounds good! The last thing I'll change before are the improvements you pointed out.

One task that I would like to very strongly encourage is running this on a lot of code.

Good idea. I'll do that.

Thanks a lot for all the time and effort you invested into the review!

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

87 ↗

(On Diff #52148)

Yep.

test/Analysis/MPIChecker.cpp

99 ↗

(On Diff #52148)

I'm fine with adding the notes to this test file.

114 ↗

(On Diff #52148)

Like you suggested, I'll simply declare the functions without definition.

[Alexander_Droste]

test/Analysis/MPIChecker.cpp

99 ↗

(On Diff #52148)

I had a look once more how much output this actually produces. If -analyzer-output=text is passed, 42 notes are missing. I'll add another test file which will test for these notes.

[Alexander_Droste]

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

96 ↗

(On Diff #52148)

I'll change this to the pattern you suggested.

With respect to your example. Does it come up in practice?

It's for sure a little contrived.

Wouldn't you warn on the second nonblocking request anyway?

Yes.

Could you add such an example to the tests?

Sure.

[Alexander_Droste]

• added test file to test for note diagnostics
• changed BugReportVisitor to detect request usage purely based on state and existence of a request
• added test that showcases a triple nonblocking usage of a request

[zaks.anna]

Awesome!

Thank you for investing SO MUCH time into improving the checker and addressing the review comments.
Do you have commit access?

Nit: Please, use lower case letters for test names to be consistent with the rest.

[Alexander_Droste]

• lower case letters for test filenames

Yeah; I'm excited to see that this code will now be part of LLVM. Thanks to everybody reviewing the patch!
I don't have commit access. Can you commit the bundle of related patches for me?

[xazax.hun]

Anna, will you commit this, or do you want me to commit the patches?

[dcoughlin]

This doesn't compile under gcc so it broke the bots. The fix is to move the specialization of clang::ento::ProgramStateTrait for RequestMapImpl out of the global namespace and into clang::ento. I will apply and recommit.

[dcoughlin]

Fixed the compilation issues with gcc in r271977 r271981, but it is still failing with Address Sanitizer diagnostics:

18751==ERROR: AddressSanitizer: stack-use-after-return on address 0x7f0c695ebc70 at pc 0x00000867b44c bp 0x7ffe3b01d6f0 sp 0x7ffe3b01d6e8

READ of size 8 at 0x7f0c695ebc70 thread T0

#0 0x867b44b in getSourceManager /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h:448:46
#1 0x867b44b in clang::ento::BugReporter::emitReport(std::__1::unique_ptr<clang::ento::BugReport, std::__1::default_delete<clang::ento::BugReport> >) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp:3240
#2 0x8636355 in clang::ento::mpi::MPIBugReporter::reportUnmatchedWait(clang::ento::CallEvent const&, clang::ento::MemRegion const*, clang::ento::ExplodedNode const*) const /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp:82:3
#3 0x843e1ee in clang::ento::mpi::MPIChecker::checkUnmatchedWaits(clang::ento::CallEvent const&, clang::ento::CheckerContext&) const /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp:88:7
#4 0x8447dc8 in checkPreCall /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.h:36:5
#5 0x8447dc8 in void clang::ento::check::PreCall::_checkCall<clang::ento::mpi::MPIChecker>(void*, clang::ento::CallEvent const&, clang::ento::CheckerContext&) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/include/clang/StaticAnalyzer/Core/Checker.h:168
#6 0x86db2f2 in operator() /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h:59:12
#7 0x86db2f2 in runChecker /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp:269
#8 0x86db2f2 in expandGraphWithCheckers<(anonymous namespace)::CheckCallContext> /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp:123
#9 0x86db2f2 in clang::ento::CheckerManager::runCheckersForCallEvent(bool, clang::ento::ExplodedNodeSet&, clang::ento::ExplodedNodeSet const&, clang::ento::CallEvent const&, clang::ento::ExprEngine&, bool) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp:285
#10 0x8782a84 in runCheckersForPreCall /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h:252:5
#11 0x8782a84 in clang::ento::ExprEngine::evalCall(clang::ento::ExplodedNodeSet&, clang::ento::ExplodedNode*, clang::ento::CallEvent const&) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp:509
#12 0x878205b in clang::ento::ExprEngine::VisitCallExpr(clang::CallExpr const*, clang::ento::ExplodedNode*, clang::ento::ExplodedNodeSet&) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp:487:5
#13 0x872a0d8 in clang::ento::ExprEngine::Visit(clang::Stmt const*, clang::ento::ExplodedNode*, clang::ento::ExplodedNodeSet&) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp:1104:7
#14 0x87210bf in clang::ento::ExprEngine::ProcessStmt(clang::CFGStmt, clang::ento::ExplodedNode*) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp:448:5
#15 0x87207ae in clang::ento::ExprEngine::processCFGElement(clang::CFGElement, clang::ento::ExplodedNode*, unsigned int, clang::ento::NodeBuilderContext*) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp:297:7
#16 0x86fc7a6 in clang::ento::CoreEngine::HandlePostStmt(clang::CFGBlock const*, unsigned int, clang::ento::ExplodedNode*) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp:515:5
#17 0x86fafed in clang::ento::CoreEngine::dispatchWorkItem(clang::ento::ExplodedNode*, clang::ProgramPoint, clang::ento::WorkListUnit const&) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp:274:7
#18 0x86f9891 in clang::ento::CoreEngine::ExecuteWorkList(clang::LocationContext const*, unsigned int, llvm::IntrusiveRefCntPtr<clang::ento::ProgramState const>) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp:231:5
#19 0x67f1ab5 in ExecuteWorkList /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h:109:12
#20 0x67f1ab5 in (anonymous namespace)::AnalysisConsumer::ActionExprEngine(clang::Decl*, bool, clang::ento::ExprEngine::InliningModes, llvm::DenseSet<clang::Decl const*, llvm::DenseMapInfo<clang::Decl const*> >*) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp:664
#21 0x67f0ae2 in RunPathSensitiveChecks /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp:694:5
#22 0x67f0ae2 in (anonymous namespace)::AnalysisConsumer::HandleCode(clang::Decl*, unsigned int, clang::ento::ExprEngine::InliningModes, llvm::DenseSet<clang::Decl const*, llvm::DenseMapInfo<clang::Decl const*> >*) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp:632
#23 0x67dc135 in HandleDeclsCallGraph /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp:495:5
#24 0x67dc135 in (anonymous namespace)::AnalysisConsumer::HandleTranslationUnit(clang::ASTContext&) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp:547
#25 0x687dae4 in clang::ParseAST(clang::Sema&, bool, bool) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/Parse/ParseAST.cpp:167:3
#26 0x51c090b in clang::FrontendAction::Execute() /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/Frontend/FrontendAction.cpp:457:8
#27 0x510f614 in clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/Frontend/CompilerInstance.cpp:876:7
#28 0x537fa92 in clang::ExecuteCompilerInvocation(clang::CompilerInstance*) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp:241:18
#29 0x8fc2f2 in cc1_main(llvm::ArrayRef<char const*>, char const*, void*) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/tools/driver/cc1_main.cpp:116:13
#30 0x8f6a88 in ExecuteCC1Tool /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/tools/driver/driver.cpp:301:12
#31 0x8f6a88 in main /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/tools/driver/driver.cpp:381
#32 0x7f0c6c208f44 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x21f44)
#33 0x816952 in _start (/mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/bin/clang-3.9+0x816952)

Address 0x7f0c695ebc70 is located in stack of thread T0 at offset 1136 in frame

  #0 0x67f130f in (anonymous namespace)::AnalysisConsumer::ActionExprEngine(clang::Decl*, bool, clang::ento::ExprEngine::InliningModes, llvm::DenseSet<clang::Decl const*, llvm::DenseMapInfo<clang::Decl const*> >*) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp:644

This frame has 5 object(s):
  [32, 184) 'P.i'
  [256, 260) 'FD.i'
  [272, 296) 'ref.tmp.i'
  [336, 344) 'agg.tmp.i'
  [368, 1248) 'Eng' <== Memory access at offset 1136 is inside this variable

HINT: this may be a false positive if your program uses some custom stack unwind mechanism or swapcontext

(longjmp and C++ exceptions *are* supported)

SUMMARY: AddressSanitizer: stack-use-after-return /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h:448:46 in getSourceManager
Shadow bytes around the buggy address:

0x0fe20d2b5730: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
0x0fe20d2b5740: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
0x0fe20d2b5750: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
0x0fe20d2b5760: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
0x0fe20d2b5770: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5

>0x0fe20d2b5780: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5[f5]f5

0x0fe20d2b5790: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
0x0fe20d2b57a0: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
0x0fe20d2b57b0: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
0x0fe20d2b57c0: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
0x0fe20d2b57d0: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5

Shadow byte legend (one shadow byte represents 8 application bytes):

Addressable:           00
Partially addressable: 01 02 03 04 05 06 07 
Heap left redzone:       fa
Heap right redzone:      fb
Freed heap region:       fd
Stack left redzone:      f1
Stack mid redzone:       f2
Stack right redzone:     f3
Stack partial redzone:   f4
Stack after return:      f5
Stack use after scope:   f8
Global redzone:          f9
Global init order:       f6
Poisoned by user:        f7
Container overflow:      fc
Array cookie:            ac
Intra object redzone:    bb
ASan internal:           fe
Left alloca redzone:     ca
Right alloca redzone:    cb

18751==ABORTING

---

Testing: 0
FAIL: Clang :: Analysis/mpicheckernotes.cpp (317 of 9433)

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt

   MallocChecker.cpp
   MallocOverflowSecurityChecker.cpp
   MallocSizeofChecker.cpp
+  MPI-Checker/MPIBugReporter.cpp
+  MPI-Checker/MPIChecker.cpp
+  MPI-Checker/MPICheckerAST.cpp
+  MPI-Checker/MPICheckerPathSensitive.cpp
+  MPI-Checker/MPIFunctionClassifier.cpp
+  MPI-Checker/TranslationUnitVisitor.cpp
+  MPI-Checker/Utility.cpp
   NSAutoreleasePoolChecker.cpp
   NSErrorChecker.cpp
   NoReturnFunctionChecker.cpp

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/Checkers.td

 def DeadCode : Package<"deadcode">;
 def DeadCodeAlpha : Package<"deadcode">, InPackage<Alpha>, Hidden;
 
+def MPI : Package<"mpi">;
+
 def Security : Package <"security">;
 def InsecureAPI : Package<"insecureAPI">, InPackage<Security>;
 def SecurityAlpha : Package<"security">, InPackage<Alpha>, Hidden;

   DescFile<"ObjCContainersChecker.cpp">;
 
 }
+
+let ParentPackage = MPI in {
+def MPIChecker : Checker<"MPI-Checker">,
+  HelpText<"Checks MPI code">,
+  DescFile<"MPIChecker.cpp">;
+} // end "MPI"
+
 //===----------------------------------------------------------------------===//
 // Checkers for LLVM development.
 //===----------------------------------------------------------------------===//

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Container.h

+//===-- Container.h - convenience templates for containers ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines convenience templates for C++ container class usage.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_CONTAINER_H
+#define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_CONTAINER_H
+
+#include <algorithm>
+
+namespace cont {
+
+/// Returns true if \p Container contains \p Element.
+template <typename T, typename E>
+bool contains(const T &Container, const E &Element) {
+  return std::find(Container.begin(), Container.end(), Element) !=
+         Container.end();
+}
+
+} // end of namespace: cont
+
+#endif

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.h

+//===-- MPIBugReporter.h - bug reporter -----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines prefabricated reports which are emitted in
+/// case of MPI related bugs, detected by AST-based and path-sensitive analysis.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPIBUGREPORTER_H
+#define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPIBUGREPORTER_H
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "MPITypes.h"
+#include "MPIFunctionClassifier.h"
+
+namespace clang {
+namespace mpi {
+
+class MPIBugReporter {
+public:
+  MPIBugReporter(clang::ento::BugReporter &BR,
+                 const clang::ento::CheckerBase &CB,
+                 clang::ento::AnalysisManager &AM)
+      : BugReporter{BR}, CkrBase{CB}, AnalysisManager{AM}, FuncClassifier{AM} {
+    UnmatchedWaitBugType.reset(
+        new clang::ento::BugType(&CB, "Unmatched wait", MPIError));
+    DoubleNonblockingBugType.reset(
+        new clang::ento::BugType(&CB, "Double nonblocking", MPIError));
+    MissingWaitBugType.reset(
+        new clang::ento::BugType(&CB, "Missing wait", MPIError));
+  }
+
+  // ast reports ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
+
+  /// Report mismatch between buffer type and MPI datatype.
+  ///
+  /// \param MPICallExpr MPI call to report the mismatch for
+  /// \param IdxPair buffer type, MPI type index pair of the mismatch
+  /// \param BufferType buffer type
+  /// \param MPIType MPI datatype as string
+  void reportTypeMismatch(const clang::CallExpr *MPICallExpr,
+                          const std::pair<size_t, size_t> &IdxPair,
+                          const std::string &BufferTypeName,
+                          const std::string MPIType) const;
+
+  /// Report if a buffer is not passed as a single pointer.
+  ///
+  /// \param MPICallExpr MPI call to report incorrect buffer referencing for
+  /// \param Idx index of incorrectly referenced buffer
+  /// \param PointerCount pointer count
+  void reportIncorrectBufferReferencing(const clang::CallExpr *MPICallExpr,
+                                        const size_t Idx,
+                                        const size_t PointerCount) const;
+
+  /// Report non-integer type usage at indices where not allowed. (e.g. rank)
+  ///
+  /// \param MPICallExpr MPI call to report the invalid argument type for
+  /// \param Idx argument index of invalid argument type
+  void reportInvalidArgumentType(const clang::CallExpr *const MPICallExpr,
+                                 const size_t Idx) const;
+
+  // path-sensitive reports –––––––––––––––––––––––––––––––––––––––––––––––
+
+  /// Report duplicate request use by nonblocking calls without intermediate
+  /// wait.
+  ///
+  /// \param MPICallEvent MPI call that caused the double nonblocking
+  /// \param Req request that was used by two nonblocking calls in sequence
+  /// \param RequestRegion memory region of the request
+  /// \param ExplNode node in the graph the bug appeared at
+  void reportDoubleNonblocking(
+      const clang::ento::CallEvent &MPICallEvent, const ento::mpi::Request &Req,
+      const clang::ento::MemRegion *const RequestRegion,
+      const clang::ento::ExplodedNode *const ExplNode) const;
+
+  /// Report a missing wait for a nonblocking call. A missing wait report
+  /// is emitted if a nonblocking call is not matched in the scope of a
+  /// function.
+  ///
+  /// \param Req request that is not matched by a wait
+  /// \param RequestRegion memory region of the request
+  /// \param ExplNode node in the graph the bug appeared at
+  void reportMissingWait(const ento::mpi::Request &Req,
+                         const clang::ento::MemRegion *const RequestRegion,
+                         const clang::ento::ExplodedNode *const ExplNode,
+                         clang::ento::CheckerContext &Ctx) const;
+
+  /// Report a wait on a request that has not been used at all before.
+  ///
+  /// \param CE wait call that uses the request
+  /// \param ReqRegion memory region of the request
+  /// \param ExplNode node in the graph the bug appeared at
+  void
+  reportUnmatchedWait(const clang::ento::CallEvent &CE,
+                      const clang::ento::MemRegion *const RequestRegion,
+                      const clang::ento::ExplodedNode *const ExplNode) const;
+
+  const clang::Decl *CurrentFunctionDecl = nullptr;
+
+private:
+  const std::string MPIError{"MPI Error"};
+
+  // path-sensitive bug types
+  std::unique_ptr<clang::ento::BugType> UnmatchedWaitBugType;
+  std::unique_ptr<clang::ento::BugType> MissingWaitBugType;
+  std::unique_ptr<clang::ento::BugType> DoubleNonblockingBugType;
+
+  clang::ento::BugReporter &BugReporter;
+  const clang::ento::CheckerBase &CkrBase;
+  clang::ento::AnalysisManager &AnalysisManager;
+  const clang::mpi::MPIFunctionClassifier FuncClassifier;
+
+  /// Bug visitor class to include the previous node into the BugReport path.
+  class RequestNodeVisitor
+      : public clang::ento::BugReporterVisitorImpl<RequestNodeVisitor> {
+  public:
+    RequestNodeVisitor(const clang::ento::MemRegion *const MemoryRegion,
+                       std::string ErrText,
+                       const clang::mpi::MPIFunctionClassifier &FC)
+        : RequestRegion(MemoryRegion), ErrorText{ErrText}, FuncClassifier{FC} {}
+
+    void Profile(llvm::FoldingSetNodeID &ID) const override {
+      static int X = 0;
+      ID.AddPointer(&X);
+      ID.AddPointer(RequestRegion);
+    }
+
+    clang::ento::PathDiagnosticPiece *
+    VisitNode(const clang::ento::ExplodedNode *N,
+              const clang::ento::ExplodedNode *PrevN,
+              clang::ento::BugReporterContext &BRC,
+              clang::ento::BugReport &BR) override;
+
+  private:
+    const clang::ento::MemRegion *const RequestRegion;
+    bool IsNodeFound{false};
+    std::string ErrorText;
+    const clang::mpi::MPIFunctionClassifier &FuncClassifier;
+  };
+};
+
+} // end of namespace: mpi
+} // end of namespace: clang
+
+#endif

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

+//===-- MPIBugReporter.cpp - bug reporter -----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines prefabricated reports which are emitted in
+/// case of MPI related bugs, detected by AST-based and path-sensitive analysis.
+///
+//===----------------------------------------------------------------------===//
+
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "MPIBugReporter.h"
+#include "Utility.h"
+#include "MPICheckerPathSensitive.h"
+
+using namespace clang::ento;
+
+namespace clang {
+namespace mpi {
+
+// bug reports ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
+
+// ast reports ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
+void MPIBugReporter::reportTypeMismatch(
+    const CallExpr *MPICallExpr, const std::pair<size_t, size_t> &IdxPair,
+    const std::string &BufferTypeName, const std::string MPIType) const {
+  auto ADC = AnalysisManager.getAnalysisDeclContext(CurrentFunctionDecl);
+  PathDiagnosticLocation Location = PathDiagnosticLocation::createBegin(
+      MPICallExpr, BugReporter.getSourceManager(), ADC);
+
+  SourceRange MPICallExprRange = MPICallExpr->getCallee()->getSourceRange();
+  std::string BT{"Type mismatch"};
+  std::string ErrorText{"Buffer type '" + BufferTypeName +
+                        +"' and specified MPI type '" + MPIType +
+                        "' do not match. "};
+
+  llvm::SmallVector<SourceRange, 3> SourceRanges;
+  SourceRanges.push_back(MPICallExprRange);
+  SourceRanges.push_back(MPICallExpr->getArg(IdxPair.first)->getSourceRange());
+  SourceRanges.push_back(MPICallExpr->getArg(IdxPair.second)->getSourceRange());
+
+  BugReporter.EmitBasicReport(ADC->getDecl(), &CkrBase, BT, MPIError, ErrorText,
+                              Location, SourceRanges);
+}
+
+void MPIBugReporter::reportIncorrectBufferReferencing(
+    const CallExpr *MPICallExpr, const size_t Idx,
+    const size_t PointerCount) const {
+  auto ADC = AnalysisManager.getAnalysisDeclContext(CurrentFunctionDecl);
+  PathDiagnosticLocation Location = PathDiagnosticLocation::createBegin(
+      MPICallExpr, BugReporter.getSourceManager(), ADC);
+
+  SourceRange MPICallExprRange = MPICallExpr->getCallee()->getSourceRange();
+  std::string BT{"Incorrect buffer referencing"};
+  std::string ErrorText{
+      "Buffer is not correctly dereferenced. It is passed as a " +
+      std::string(PointerCount, '*') + " pointer. "};
+
+  llvm::SmallVector<SourceRange, 2> SourceRanges;
+  SourceRanges.push_back(MPICallExprRange);
+  SourceRanges.push_back(MPICallExpr->getArg(Idx)->getSourceRange());
+
+  BugReporter.EmitBasicReport(ADC->getDecl(), &CkrBase, BT, MPIError, ErrorText,
+                              Location, SourceRanges);
+}
+
+void MPIBugReporter::reportInvalidArgumentType(
+    const CallExpr *const MPICallExpr, const size_t Idx) const {
+  auto ADC = AnalysisManager.getAnalysisDeclContext(CurrentFunctionDecl);
+  PathDiagnosticLocation Location = PathDiagnosticLocation::createBegin(
+      MPICallExpr, BugReporter.getSourceManager(), ADC);
+
+  std::string IndexAsString{std::to_string(Idx)};
+  SourceRange MPICallExprRange = MPICallExpr->getCallee()->getSourceRange();
+  std::string BT{"Invalid argument type"};
+  std::string ErrorText{"The type, argument at index " + IndexAsString +
+                        " evaluates to, is not an integer type. "};
+
+  SmallVector<SourceRange, 3> SourceRanges;
+  SourceRanges.push_back(MPICallExprRange);
+  SourceRanges.push_back(MPICallExpr->getArg(Idx)->getSourceRange());
+  BugReporter.EmitBasicReport(ADC->getDecl(), &CkrBase, BT, MPIError, ErrorText,
+                              Location, SourceRanges);
+}
+
+// path-sensitive reports –––––––––––––––––––––––––––––––––––––––––––––––––
+
+void MPIBugReporter::reportDoubleNonblocking(
+    const CallEvent &MPICallEvent, const ento::mpi::Request &Req,
+    const MemRegion *const RequestRegion,
+    const ExplodedNode *const ExplNode) const {
+
+  // Check if double nonblocking was caused by the same call.
+  std::string ErrorText;
+  ErrorText = "Double nonblocking on request " +
+              util::variableName(RequestRegion) + ". ";
+
+  auto Report = llvm::make_unique<BugReport>(*DoubleNonblockingBugType,
+                                             ErrorText, ExplNode);
+
+  Report->addRange(MPICallEvent.getSourceRange());
+  SourceRange Range = util::sourceRange(RequestRegion);
+  if (Range.isValid())
+    Report->addRange(Range);
+
+  Report->addVisitor(llvm::make_unique<RequestNodeVisitor>(
+      RequestRegion, "Request is previously used by nonblocking call here. ",
+      FuncClassifier));
+  Report->markInteresting(RequestRegion);
+
+  BugReporter.emitReport(std::move(Report));
+}
+
+void MPIBugReporter::reportMissingWait(const ento::mpi::Request &Req,
+                                       const MemRegion *const RequestRegion,
+                                       const ExplodedNode *const ExplNode,
+                                       CheckerContext &Ctx) const {
+  std::string ErrorText{"Request " + util::variableName(RequestRegion) +
+                        " has no matching wait. "};
+
+  auto Report =
+      llvm::make_unique<BugReport>(*MissingWaitBugType, ErrorText, ExplNode);
+
+  SourceRange Range = util::sourceRange(RequestRegion);
+  if (Range.isValid())
+    Report->addRange(Range);
+  Report->addVisitor(llvm::make_unique<RequestNodeVisitor>(
+      RequestRegion, "Request is previously used by nonblocking call here. ",
+      FuncClassifier));
+  Report->markInteresting(RequestRegion);
+
+  BugReporter.emitReport(std::move(Report));
+}
+
+void MPIBugReporter::reportUnmatchedWait(
+    const CallEvent &CE, const clang::ento::MemRegion *const RequestRegion,
+    const ExplodedNode *const ExplNode) const {
+  std::string ErrorText{"Request " + util::variableName(RequestRegion) +
+                        " has no matching nonblocking call. "};
+
+  auto Report =
+      llvm::make_unique<BugReport>(*UnmatchedWaitBugType, ErrorText, ExplNode);
+
+  Report->addRange(CE.getSourceRange());
+  SourceRange Range = util::sourceRange(RequestRegion);
+  if (Range.isValid())
+    Report->addRange(Range);
+
+  BugReporter.emitReport(std::move(Report));
+}
+
+PathDiagnosticPiece *MPIBugReporter::RequestNodeVisitor::VisitNode(
+    const ExplodedNode *N, const ExplodedNode *PrevN, BugReporterContext &BRC,
+    BugReport &BR) {
+
+  if (IsNodeFound)
+    return nullptr;
+
+  if (Optional<PreStmt> SP = N->getLocation().getAs<PreStmt>()) {
+    if (const CallExpr *CE = clang::dyn_cast<CallExpr>(SP->getStmt())) {
+
+      auto FuncIdentifier = CE->getDirectCallee()->getIdentifier();
+      CallEventManager &Mgr =
+          N->getState()->getStateManager().getCallEventManager();
+      // Find previous call that uses the request.
+      CallEventRef<> Call =
+          Mgr.getSimpleCall(CE, N->getState(), N->getLocationContext());
+
+      bool ReqUsedByCall{false};
+      // nonblocking
+      if (FuncClassifier.isNonBlockingType(FuncIdentifier)) {
+        SVal SV = Call->getArgSVal(Call->getNumArgs() - 1);
+        if (SV.getAsRegion() == RequestRegion) {
+          ReqUsedByCall = true;
+        }
+      }
+      // waitall
+      else if (FuncClassifier.isMPI_Waitall(FuncIdentifier)) {
+        const MemRegion *const OtherReqRegion =
+            Call->getArgSVal(1).getAsRegion();
+        if (OtherReqRegion == RequestRegion ||
+            (RequestRegion->isSubRegionOf(OtherReqRegion))) {
+          ReqUsedByCall = true;
+        }
+      }
+      // wait
+      else if (FuncClassifier.isMPI_Wait(FuncIdentifier)) {
+        if (Call->getArgSVal(0).getAsRegion() == RequestRegion) {
+          ReqUsedByCall = true;
+        }
+      }
+
+      if (ReqUsedByCall) {
+        // Do not include further locations.
+        IsNodeFound = true;
+        PathDiagnosticLocation Pos(CE, BRC.getSourceManager(),
+                                   N->getLocationContext());
+
+        return new PathDiagnosticEventPiece(Pos, ErrorText);
+      }
+    }
+  }
+
+  return nullptr;
+}
+
+} // end of namespace: mpi
+} // end of namespace: clang

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

+//===-- MPIChecker.cpp - Checker Entry Point Class --------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines the main class of MPI-Checker which serves as an entry
+/// point. It is created once for each translation unit analysed.
+///
+//===----------------------------------------------------------------------===//
+
+#include "../ClangSACheckers.h"
+#include "TranslationUnitVisitor.h"
+#include "MPICheckerPathSensitive.h"
+
+using namespace clang::ento;
+
+namespace clang {
+namespace mpi {
+class MPIChecker : public Checker<check::ASTDecl<TranslationUnitDecl>,
+                                  check::PreCall, check::DeadSymbols> {
+public:
+  // ast callback–––––––––––––––––––––––––––––––––––––––––––––––––––––––
+  void checkASTDecl(const TranslationUnitDecl *TuDecl, AnalysisManager &AM,
+                    BugReporter &BR) const {
+    // Traverse translation unit.
+    TranslationUnitVisitor TuVisitor{BR, *this, AM};
+    TuVisitor.TraverseTranslationUnitDecl(
+        const_cast<TranslationUnitDecl *>(TuDecl));
+  }
+
+  // path-sensitive callbacks––––––––––––––––––––––––––––––––––––––––––––
+  void checkPreCall(const CallEvent &CE, CheckerContext &Ctx) const {
+    dynamicInit(Ctx);
+    CheckerSens->checkWaitUsage(CE, Ctx);
+    CheckerSens->checkDoubleNonblocking(CE, Ctx);
+  }
+
+  void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &Ctx) const {
+    dynamicInit(Ctx);
+    CheckerSens->checkMissingWaits(SymReaper, Ctx);
+  }
+
+private:
+  const std::unique_ptr<MPICheckerPathSensitive> CheckerSens;
+
+  void dynamicInit(CheckerContext &Ctx) const {
+    if (!CheckerSens) {
+      const_cast<std::unique_ptr<MPICheckerPathSensitive> &>(CheckerSens)
+          .reset(new MPICheckerPathSensitive(Ctx.getAnalysisManager(), this,
+                                             Ctx.getBugReporter()));
+    }
+  }
+};
+
+} // end of namespace: mpi
+} // end of namespace: clang
+
+// Registers the checker for static analysis.
+void clang::ento::registerMPIChecker(CheckerManager &MGR) {
+  MGR.registerChecker<clang::mpi::MPIChecker>();
+}

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerAST.h

+//===-- MPICheckerAST.h - AST-based checks for MPI --------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines AST-based checks, to verify correct usage of the MPI API.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPICHECKERAST_H
+#define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPICHECKERAST_H
+
+#include "MPIFunctionClassifier.h"
+#include "MPIBugReporter.h"
+#include "Container.h"
+#include "Utility.h"
+#include "TypeVisitor.h"
+
+namespace clang {
+namespace mpi {
+
+class MPICheckerAST {
+public:
+  MPICheckerAST(clang::ento::BugReporter &BR,
+                const clang::ento::CheckerBase &CB,
+                clang::ento::AnalysisManager &AM)
+      : FuncClassifier{AM}, BugReporter{BR, CB, AM}, AnalysisManager{AM} {
+    initMPITypeContainer();
+  }
+
+  using IndexPairs = llvm::SmallVector<std::pair<size_t, size_t>, 2>;
+
+  /// Checks if expressions evaluate to a non-integer type at indices where
+  /// only
+  /// integer values are valid (count, rank, tag).
+  ///
+  /// \param MPICallExpr call to check the arguments for
+  void checkForInvalidArgs(const clang::CallExpr *const MPICallExpr) const;
+
+  /// Checks if buffer type and specified MPI datatype matches.
+  /// \param MPICallExpr call to check type correspondence for
+  void checkBufferTypeMatch(const clang::CallExpr *const MPICallExpr) const;
+
+  /// Set function currently visited to pass the information to the bug
+  /// reporter, in case of a found bug.
+  ///
+  /// \param FuncDecl current function visited
+  void setCurrentlyVisitedFunction(const clang::FunctionDecl *const FuncDecl);
+
+private:
+  /// Init MPI type container to recognize all MPI types defined by the
+  /// MPI standard. (MPI_BYTE, MPI_PACKED are excluded)
+  void initMPITypeContainer();
+
+  /// Returns index pairs for each buffer, datatype pair.
+  ///
+  /// \param MPICallExpr MPI call to get the buffer, MPI datatype pairs for
+  IndexPairs
+  bufferDataTypeIndices(const clang::CallExpr *const MPICallExpr) const;
+
+  /// Return an array of indices that must be of integer type for a given
+  /// call.
+  ///
+  /// \param MPICallExpr MPI call to get the indices for
+  llvm::SmallVector<size_t, 1>
+  integerIndices(const clang::CallExpr *const MPICallExpr) const;
+
+  /// Selects an appropriate function to match the buffer type against the
+  /// specified MPI datatype.
+  ///
+  /// \param TypeVis contains information about the buffer type
+  /// \param IsBufferTypeNull if the buffer is a null pointer type
+  /// \param MPICallExpr buffer index pair is observed
+  /// \param MPIDatatypeString MPI datatype as string
+  /// \param IdxPair buffer, MPI datatype index pair
+  void selectTypeMatcher(const mpi::TypeVisitor &TypeVis, bool IsBufferTypeNull,
+                         const clang::CallExpr *const MPICallExpr,
+                         const llvm::StringRef MPIDatatypeString,
+                         const std::pair<size_t, size_t> &IdxPair) const;
+  bool matchNullPtrType(const llvm::StringRef MPIDatatype) const;
+  bool matchBoolType(const llvm::StringRef MPIDatatype) const;
+  bool matchCharType(const mpi::TypeVisitor &TypeVis,
+                     const llvm::StringRef MPIDatatype) const;
+  bool matchSignedType(const mpi::TypeVisitor &TypeVis,
+                       const llvm::StringRef MPIDatatype) const;
+  bool matchUnsignedType(const mpi::TypeVisitor &TypeVis,
+                         const llvm::StringRef MPIDatatype) const;
+  bool matchFloatType(const mpi::TypeVisitor &TypeVis,
+                      const llvm::StringRef MPIDatatype) const;
+  bool matchComplexCType(const mpi::TypeVisitor &TypeVis,
+                         const llvm::StringRef MPIDatatype) const;
+  bool matchComplexCPPType(const mpi::TypeVisitor &TypeVis,
+                           const llvm::StringRef MPIDatatype) const;
+  bool matchExactWidthType(const mpi::TypeVisitor &TypeVis,
+                           const llvm::StringRef MPIDatatype) const;
+
+  const MPIFunctionClassifier FuncClassifier;
+  llvm::SmallVector<std::string, 32> MPITypes;
+  MPIBugReporter BugReporter;
+  clang::ento::AnalysisManager &AnalysisManager;
+};
+
+} // end of namespace: mpi
+} // end of namespace: clang
+
+#endif

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerAST.cpp

+//===-- MPICheckerAST.cpp - AST-based checks for MPI ------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines AST-based checks, to verify correct usage of the MPI API.
+///
+//===----------------------------------------------------------------------===//
+
+#include "MPICheckerAST.h"
+
+namespace clang {
+namespace mpi {
+
+void MPICheckerAST::initMPITypeContainer() {
+  MPITypes = {"MPI_DATATYPE_NULL",
+              "MPI_C_BOOL",
+              "MPI_CHAR",
+              "MPI_SIGNED_CHAR",
+              "MPI_UNSIGNED_CHAR",
+              "MPI_WCHAR",
+              "MPI_INT",
+              "MPI_LONG",
+              "MPI_SHORT",
+              "MPI_LONG_LONG",
+              "MPI_LONG_LONG_INT",
+              "MPI_UNSIGNED",
+              "MPI_UNSIGNED_SHORT",
+              "MPI_UNSIGNED_LONG",
+              "MPI_UNSIGNED_LONG_LONG",
+              "MPI_FLOAT",
+              "MPI_DOUBLE",
+              "MPI_LONG_DOUBLE",
+              "MPI_C_COMPLEX",
+              "MPI_C_FLOAT_COMPLEX",
+              "MPI_C_DOUBLE_COMPLEX",
+              "MPI_C_LONG_DOUBLE_COMPLEX",
+              "MPI_INT8_T",
+              "MPI_INT16_T",
+              "MPI_INT32_T",
+              "MPI_INT64_T",
+              "MPI_UINT8_T",
+              "MPI_UINT16_T",
+              "MPI_UINT32_T",
+              "MPI_UINT64_T",
+              "MPI_CXX_BOOL",
+              "MPI_CXX_FLOAT_COMPLEX",
+              "MPI_CXX_DOUBLE_COMPLEX",
+              "MPI_CXX_LONG_DOUBLE_COMPLEX"};
+}
+
+void MPICheckerAST::checkBufferTypeMatch(
+    const clang::CallExpr *const MPICallExpr) const {
+  // One pair consists of a {bufferIdx, MPIDatatypeIdx}.
+  IndexPairs IdxPairs = bufferDataTypeIndices(MPICallExpr);
+
+  // For every buffer, MPI pair in function, check if their types match.
+  for (const auto &IdxPair : IdxPairs) {
+    const auto BufferType =
+        MPICallExpr->getArg(IdxPair.first)->IgnoreImpCasts()->getType();
+
+    // Collect buffer type information.
+    const mpi::TypeVisitor TypeVis{BufferType};
+
+    // Get MPI data type as string.
+    const StringRef MPIDatatypeString{util::sourceRangeAsStringRef(
+        MPICallExpr->getArg(IdxPair.second)->getSourceRange(),
+        AnalysisManager)};
+
+    // Detect null pointer constant type.
+    const bool IsBufferTypeNull =
+        MPICallExpr->getArg(IdxPair.first)
+            ->isNullPointerConstant(AnalysisManager.getASTContext(),
+                                    Expr::NPC_ValueDependentIsNull);
+
+    // if MPI type not known or null pointer constant
+    if (!cont::contains(MPITypes, MPIDatatypeString) || IsBufferTypeNull)
+      return;
+
+    // Check if the buffer is correctly referenced.
+    if (TypeVis.pointerCount() != 1) {
+      BugReporter.reportIncorrectBufferReferencing(MPICallExpr, IdxPair.first,
+                                                   TypeVis.pointerCount());
+    }
+
+    selectTypeMatcher(TypeVis, IsBufferTypeNull, MPICallExpr, MPIDatatypeString,
+                      IdxPair);
+  }
+}
+
+MPICheckerAST::IndexPairs MPICheckerAST::bufferDataTypeIndices(
+    const clang::CallExpr *const MPICallExpr) const {
+  IndexPairs IdxPairs;
+
+  const IdentifierInfo *const Ident = util::getIdentInfo(MPICallExpr);
+
+  if (FuncClassifier.isPointToPointType(Ident)) {
+    IdxPairs.push_back({MPIPointToPoint::Buf, MPIPointToPoint::Datatype});
+  } else if (FuncClassifier.isCollectiveType(Ident)) {
+    if (FuncClassifier.isReduceType(Ident)) {
+      // Only check buffer type if is not inplace.
+      if (util::sourceRangeAsStringRef(MPICallExpr->getArg(0)->getSourceRange(),
+                                       AnalysisManager) != "MPI_IN_PLACE") {
+        IdxPairs.push_back({0, 3});
+      }
+      IdxPairs.push_back({1, 3});
+    } else if (FuncClassifier.isScatterType(Ident) ||
+               FuncClassifier.isGatherType(Ident) ||
+               FuncClassifier.isAlltoallType(Ident)) {
+      IdxPairs.push_back({0, 2});
+      IdxPairs.push_back({3, 5});
+    } else if (FuncClassifier.isBcastType(Ident)) {
+      IdxPairs.push_back({0, 2});
+    }
+  }
+  return IdxPairs;
+}
+
+void MPICheckerAST::selectTypeMatcher(
+    const mpi::TypeVisitor &TypeVis, const bool IsBufferTypeNull,
+    const clang::CallExpr *const MPICallExpr, const StringRef MPIDatatypeString,
+    const std::pair<size_t, size_t> &IdxPair) const {
+  const clang::BuiltinType *BuiltinTy = TypeVis.builtinType();
+  bool IsTypeMatching{true};
+
+  if (IsBufferTypeNull) {
+    IsTypeMatching = matchNullPtrType(MPIDatatypeString);
+  } else if (TypeVis.isTypedefType()) {
+    IsTypeMatching = matchExactWidthType(TypeVis, MPIDatatypeString);
+  }
+  // Check for complex-floating C types (e.g. float _Complex).
+  else if (TypeVis.isComplexCType()) {
+    IsTypeMatching = matchComplexCType(TypeVis, MPIDatatypeString);
+  }
+  // Check for complex-floating CPP types (e.g. std::complex<double>).
+  else if (TypeVis.templateType() && TypeVis.templateName() == "complex") {
+    IsTypeMatching = matchComplexCPPType(TypeVis, MPIDatatypeString);
+  }
+  // Check for basic builtin types (e.g. int, char).
+  else if (!BuiltinTy) {
+    return; // if no builtin type cancel checking
+  } else if (BuiltinTy->isBooleanType()) {
+    IsTypeMatching = matchBoolType(MPIDatatypeString);
+  } else if (BuiltinTy->isAnyCharacterType()) {
+    IsTypeMatching = matchCharType(TypeVis, MPIDatatypeString);
+  } else if (BuiltinTy->isSignedInteger()) {
+    IsTypeMatching = matchSignedType(TypeVis, MPIDatatypeString);
+  } else if (BuiltinTy->isUnsignedIntegerType()) {
+    IsTypeMatching = matchUnsignedType(TypeVis, MPIDatatypeString);
+  } else if (BuiltinTy->isFloatingType()) {
+    IsTypeMatching = matchFloatType(TypeVis, MPIDatatypeString);
+  }
+
+  if (!IsTypeMatching) {
+    std::string BufferTypeName;
+    BufferTypeName = TypeVis.derefUnqualType().getAsString();
+    BugReporter.reportTypeMismatch(MPICallExpr, IdxPair, BufferTypeName,
+                                   MPIDatatypeString);
+  }
+}
+
+bool MPICheckerAST::matchNullPtrType(const llvm::StringRef MPIDatatype) const {
+  return (MPIDatatype == "MPI_DATATYPE_NULL");
+}
+
+bool MPICheckerAST::matchBoolType(const llvm::StringRef MPIDatatype) const {
+  return (MPIDatatype == "MPI_C_BOOL" || MPIDatatype == "MPI_CXX_BOOL");
+}
+
+bool MPICheckerAST::matchCharType(const mpi::TypeVisitor &TypeVis,
+                                  const llvm::StringRef MPIDatatype) const {
+  bool IsTypeMatching;
+  switch (TypeVis.builtinType()->getKind()) {
+  case BuiltinType::SChar:
+    IsTypeMatching =
+        (MPIDatatype == "MPI_CHAR" || MPIDatatype == "MPI_SIGNED_CHAR");
+    break;
+  case BuiltinType::Char_S:
+    IsTypeMatching =
+        (MPIDatatype == "MPI_CHAR" || MPIDatatype == "MPI_SIGNED_CHAR");
+    break;
+  case BuiltinType::UChar:
+    IsTypeMatching = (MPIDatatype == "MPI_UNSIGNED_CHAR");
+    break;
+  case BuiltinType::Char_U:
+    IsTypeMatching = (MPIDatatype == "MPI_UNSIGNED_CHAR");
+    break;
+  case BuiltinType::WChar_S:
+    IsTypeMatching = (MPIDatatype == "MPI_WCHAR");
+    break;
+  case BuiltinType::WChar_U:
+    IsTypeMatching = (MPIDatatype == "MPI_WCHAR");
+    break;
+
+  default:
+    IsTypeMatching = true;
+  }
+
+  return IsTypeMatching;
+}
+
+bool MPICheckerAST::matchSignedType(const mpi::TypeVisitor &TypeVis,
+                                    const llvm::StringRef MPIDatatype) const {
+  bool IsTypeMatching;
+
+  switch (TypeVis.builtinType()->getKind()) {
+  case BuiltinType::Int:
+    IsTypeMatching = (MPIDatatype == "MPI_INT");
+    break;
+  case BuiltinType::Long:
+    IsTypeMatching = (MPIDatatype == "MPI_LONG");
+    break;
+  case BuiltinType::Short:
+    IsTypeMatching = (MPIDatatype == "MPI_SHORT");
+    break;
+  case BuiltinType::LongLong:
+    IsTypeMatching =
+        (MPIDatatype == "MPI_LONG_LONG" || MPIDatatype == "MPI_LONG_LONG_INT");
+    break;
+  default:
+    IsTypeMatching = true;
+  }
+
+  return IsTypeMatching;
+}
+
+bool MPICheckerAST::matchUnsignedType(const mpi::TypeVisitor &TypeVis,
+                                      const llvm::StringRef MPIDatatype) const {
+  bool IsTypeMatching;
+
+  switch (TypeVis.builtinType()->getKind()) {
+  case BuiltinType::UInt:
+    IsTypeMatching = (MPIDatatype == "MPI_UNSIGNED");
+    break;
+  case BuiltinType::UShort:
+    IsTypeMatching = (MPIDatatype == "MPI_UNSIGNED_SHORT");
+    break;
+  case BuiltinType::ULong:
+    IsTypeMatching = (MPIDatatype == "MPI_UNSIGNED_LONG");
+    break;
+  case BuiltinType::ULongLong:
+    IsTypeMatching = (MPIDatatype == "MPI_UNSIGNED_LONG_LONG");
+    break;
+
+  default:
+    IsTypeMatching = true;
+  }
+  return IsTypeMatching;
+}
+
+bool MPICheckerAST::matchFloatType(const mpi::TypeVisitor &TypeVis,
+                                   const llvm::StringRef MPIDatatype) const {
+  bool IsTypeMatching;
+
+  switch (TypeVis.builtinType()->getKind()) {
+  case BuiltinType::Float:
+    IsTypeMatching = (MPIDatatype == "MPI_FLOAT");
+    break;
+  case BuiltinType::Double:
+    IsTypeMatching = (MPIDatatype == "MPI_DOUBLE");
+    break;
+  case BuiltinType::LongDouble:
+    IsTypeMatching = (MPIDatatype == "MPI_LONG_DOUBLE");
+    break;
+  default:
+    IsTypeMatching = true;
+  }
+  return IsTypeMatching;
+}
+
+bool MPICheckerAST::matchComplexCType(const mpi::TypeVisitor &TypeVis,
+                                      const llvm::StringRef MPIDatatype) const {
+  bool IsTypeMatching;
+
+  switch (TypeVis.builtinType()->getKind()) {
+  case BuiltinType::Float:
+    IsTypeMatching = (MPIDatatype == "MPI_C_COMPLEX" ||
+                      MPIDatatype == "MPI_C_FLOAT_COMPLEX");
+    break;
+  case BuiltinType::Double:
+    IsTypeMatching = (MPIDatatype == "MPI_C_DOUBLE_COMPLEX");
+    break;
+  case BuiltinType::LongDouble:
+    IsTypeMatching = (MPIDatatype == "MPI_C_LONG_DOUBLE_COMPLEX");
+    break;
+  default:
+    IsTypeMatching = true;
+  }
+
+  return IsTypeMatching;
+}
+
+bool MPICheckerAST::matchComplexCPPType(
+    const mpi::TypeVisitor &TypeVis, const llvm::StringRef MPIDatatype) const {
+  bool IsTypeMatching;
+
+  switch (TypeVis.builtinType()->getKind()) {
+  case BuiltinType::Float:
+    IsTypeMatching = (MPIDatatype == "MPI_CXX_FLOAT_COMPLEX");
+    break;
+  case BuiltinType::Double:
+    IsTypeMatching = (MPIDatatype == "MPI_CXX_DOUBLE_COMPLEX");
+    break;
+  case BuiltinType::LongDouble:
+    IsTypeMatching = (MPIDatatype == "MPI_CXX_LONG_DOUBLE_COMPLEX");
+    break;
+  default:
+    IsTypeMatching = true;
+  }
+
+  return IsTypeMatching;
+}
+
+bool MPICheckerAST::matchExactWidthType(
+    const mpi::TypeVisitor &TypeVis, const llvm::StringRef MPIDatatype) const {
+  // Check typedef type match.
+  // No break needs to be specified for string switch.
+  bool IsTypeMatching = llvm::StringSwitch<bool>(TypeVis.typedefTypeName())
+                            .Case("int8_t", (MPIDatatype == "MPI_INT8_T"))
+                            .Case("int16_t", (MPIDatatype == "MPI_INT16_T"))
+                            .Case("int32_t", (MPIDatatype == "MPI_INT32_T"))
+                            .Case("int64_t", (MPIDatatype == "MPI_INT64_T"))
+
+                            .Case("uint8_t", (MPIDatatype == "MPI_UINT8_T"))
+                            .Case("uint16_t", (MPIDatatype == "MPI_UINT16_T"))
+                            .Case("uint32_t", (MPIDatatype == "MPI_UINT32_T"))
+                            .Case("uint64_t", (MPIDatatype == "MPI_UINT64_T"))
+                            // unknown typedefs are rated as correct
+                            .Default(true);
+
+  return IsTypeMatching;
+}
+
+void MPICheckerAST::checkForInvalidArgs(
+    const clang::CallExpr *const MPICallExpr) const {
+  llvm::SmallVector<size_t, 1> IndicesToCheck{integerIndices(MPICallExpr)};
+  if (!IndicesToCheck.size())
+    return;
+
+  // Iterate indices which should have integer arguments.
+  for (const size_t Idx : IndicesToCheck) {
+    if (!MPICallExpr->getArg(Idx)
+             ->IgnoreImpCasts()
+             ->getType()
+             ->isIntegerType()) {
+      BugReporter.reportInvalidArgumentType(MPICallExpr, Idx);
+    }
+  }
+}
+
+llvm::SmallVector<size_t, 1>
+MPICheckerAST::integerIndices(const clang::CallExpr *const MPICallExpr) const {
+  llvm::SmallVector<size_t, 1> IntIndices;
+
+  const IdentifierInfo *const Ident = util::getIdentInfo(MPICallExpr);
+
+  if (FuncClassifier.isPointToPointType(Ident)) {
+    IntIndices = {MPIPointToPoint::Count, MPIPointToPoint::Rank,
+                  MPIPointToPoint::Tag};
+  } else if (FuncClassifier.isScatterType(Ident) ||
+             FuncClassifier.isGatherType(Ident)) {
+    if (FuncClassifier.isAllgatherType(Ident)) {
+      IntIndices = {1, 4};
+    } else {
+      IntIndices = {1, 4, 6};
+    }
+  } else if (FuncClassifier.isAlltoallType(Ident)) {
+    IntIndices = {1, 4};
+  } else if (FuncClassifier.isReduceType(Ident)) {
+    if (FuncClassifier.isCollToColl(Ident)) {
+      IntIndices = {2};
+    } else {
+      IntIndices = {2, 5};
+    }
+  } else if (FuncClassifier.isBcastType(Ident)) {
+    IntIndices = {1, 3};
+  }
+
+  return IntIndices;
+}
+
+void MPICheckerAST::setCurrentlyVisitedFunction(
+    const clang::FunctionDecl *const FuncDecl) {
+  BugReporter.CurrentFunctionDecl = FuncDecl;
+}
+
+} // end of namespace: mpi
+} // end of namespace: clang

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.h

+//===-- MPICheckerPathSensitive.h - path-sensitive checks -------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines path-sensitive checks, to verify correct usage of the
+/// MPI API.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPICHECKERPATHSENSITIVE_H
+#define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPICHECKERPATHSENSITIVE_H
+
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "MPIFunctionClassifier.h"
+#include "MPITypes.h"
+#include "MPIBugReporter.h"
+
+namespace clang {
+namespace mpi {
+
+class MPICheckerPathSensitive {
+public:
+  MPICheckerPathSensitive(clang::ento::AnalysisManager &AM,
+                          const clang::ento::CheckerBase *CB,
+                          clang::ento::BugReporter &BR)
+      : FuncClassifier{AM}, BugReporter{BR, *CB, AM} {}
+
+  /// Checks if a request is used by nonblocking calls multiple times
+  /// in sequence without intermediate wait. The check contains a guard,
+  /// in order to only inspect nonblocking functions.
+  ///
+  /// \param PreCallEvent MPI call to verify
+  void checkDoubleNonblocking(const clang::ento::CallEvent &PreCallEvent,
+                              clang::ento::CheckerContext &Ctx) const;
+
+  /// Checks if a request is used by a wait multiple times in sequence without
+  /// intermediate nonblocking call or if the request used by the wait
+  /// function was not used at all before. The check contains a guard,
+  /// in order to only inspect wait functions.
+  ///
+  /// \param PreCallEvent MPI call to verify
+  void checkWaitUsage(const clang::ento::CallEvent &PreCallEvent,
+                      clang::ento::CheckerContext &Ctx) const;
+
+  /// Check if a nonblocking call is not matched by a wait.
+  /// If a memory region is not alive and the last function using the
+  /// request was a nonblocking call, this is rated as a missing wait.
+  void checkMissingWaits(clang::ento::SymbolReaper &SymReaper,
+                         clang::ento::CheckerContext &Ctx);
+
+private:
+  /// Collects all memory regions of a request(array) used by a wait
+  /// function. If the wait function uses a single request, this is a single
+  /// region. For wait functions using multiple requests, multiple regions
+  /// representing elements in the array are collected.
+  ///
+  /// \param ReqRegions vector the regions get pushed into
+  /// \param MR top most region to iterate
+  /// \param CE MPI wait call using the request(s)
+  void allRegionsUsedByWait(
+      llvm::SmallVector<const clang::ento::MemRegion *, 2> &ReqRegions,
+      const clang::ento::MemRegion *const MR, const clang::ento::CallEvent &CE,
+      clang::ento::CheckerContext &Ctx) const;
+
+  /// Returns the memory region used by a wait function.
+  /// Distinguishes between MPI_Wait and MPI_Waitall.
+  ///
+  /// \param CE MPI wait call
+  const clang::ento::MemRegion *
+  topRegionUsedByWait(const clang::ento::CallEvent &CE) const;
+
+  const MPIFunctionClassifier FuncClassifier;
+  MPIBugReporter BugReporter;
+};
+
+} // end of namespace: mpi
+} // end of namespace: clang
+
+#endif

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPICheckerPathSensitive.cpp

+//===-- MPICheckerPathSensitive.cpp - path-sensitive checks -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines path-sensitive checks, to verify correct usage of the
+/// MPI API.
+///
+//===----------------------------------------------------------------------===//
+
+#include "MPICheckerPathSensitive.h"
+#include "Utility.h"
+
+namespace clang {
+namespace mpi {
+
+using namespace clang::ento;
+using namespace clang::ento::mpi;
+
+void MPICheckerPathSensitive::checkDoubleNonblocking(
+    const clang::ento::CallEvent &PreCallEvent, CheckerContext &Ctx) const {
+  if (!FuncClassifier.isNonBlockingType(PreCallEvent.getCalleeIdentifier())) {
+    return;
+  }
+  const MemRegion *const MR =
+      PreCallEvent.getArgSVal(PreCallEvent.getNumArgs() - 1).getAsRegion();
+  const ElementRegion *const ER = dyn_cast<ElementRegion>(MR);
+
+  // The region must be typed, in order to reason about it.
+  if (!isa<TypedRegion>(MR) || (ER && !isa<TypedRegion>(ER->getSuperRegion())))
+    return;
+
+  ProgramStateRef State = Ctx.getState();
+  const Request *const Req = State->get<RequestMap>(MR);
+  const ExplodedNode *const ExplNode = Ctx.getPredecessor();
+
+  if (Req && Req->CurrentState == Request::State::Nonblocking) {
+    BugReporter.reportDoubleNonblocking(PreCallEvent, *Req, MR, ExplNode);
+  }
+
+  State = State->set<RequestMap>(MR, Request::State::Nonblocking);
+  Ctx.addTransition(State);
+}
+
+void MPICheckerPathSensitive::checkWaitUsage(
+    const clang::ento::CallEvent &PreCallEvent, CheckerContext &Ctx) const {
+  if (!FuncClassifier.isWaitType(PreCallEvent.getCalleeIdentifier()))
+    return;
+  const MemRegion *const MR = topRegionUsedByWait(PreCallEvent);
+  const ElementRegion *const ER = dyn_cast<ElementRegion>(MR);
+  if (!MR)
+    return;
+
+  // The region must be typed, in order to reason about it.
+  if (!isa<TypedRegion>(MR) || (ER && !isa<TypedRegion>(ER->getSuperRegion())))
+    return;
+
+  ProgramStateRef State = Ctx.getState();
+  const ExplodedNode *const ExplNode = Ctx.getPredecessor();
+  llvm::SmallVector<const MemRegion *, 2> ReqRegions;
+  allRegionsUsedByWait(ReqRegions, MR, PreCallEvent, Ctx);
+
+  // Check all request regions used by the wait function.
+  for (const auto &ReqRegion : ReqRegions) {
+    const Request *const Req = State->get<RequestMap>(ReqRegion);
+    State = State->set<RequestMap>(ReqRegion, Request::State::Wait);
+    if (!Req) {
+      // A wait has no matching nonblocking call.
+      BugReporter.reportUnmatchedWait(PreCallEvent, ReqRegion, ExplNode);
+    }
+  }
+
+  if (!ReqRegions.empty()) {
+    Ctx.addTransition(State);
+  }
+}
+
+void MPICheckerPathSensitive::checkMissingWaits(
+    clang::ento::SymbolReaper &SymReaper, clang::ento::CheckerContext &Ctx) {
+  if (!SymReaper.hasDeadSymbols())
+    return;
+
+  ProgramStateRef State = Ctx.getState();
+  const auto &Requests = State->get<RequestMap>();
+  if (Requests.isEmpty())
+    return;
+
+  static CheckerProgramPointTag Tag("MPI-Checker", "MissingWait");
+  ExplodedNode *ErrorNode{nullptr};
+
+  auto ReqMap = State->get<RequestMap>();
+  for (const auto &Req : ReqMap) {
+    if (!SymReaper.isLiveRegion(Req.first)) {
+      if (Req.second.CurrentState == Request::State::Nonblocking) {
+
+        if (!ErrorNode) {
+          ErrorNode = Ctx.generateNonFatalErrorNode(Ctx.getState(), &Tag);
+        }
+        BugReporter.reportMissingWait(Req.second, Req.first, ErrorNode, Ctx);
+      }
+      State = State->remove<RequestMap>(Req.first);
+    }
+  }
+
+  // Transition to update the state regarding removed requests.
+  if (ErrorNode) {
+    Ctx.addTransition(State, ErrorNode);
+  } else {
+    Ctx.addTransition(State);
+  }
+}
+
+const MemRegion *MPICheckerPathSensitive::topRegionUsedByWait(
+    const clang::ento::CallEvent &CE) const {
+
+  if (FuncClassifier.isMPI_Wait(CE.getCalleeIdentifier())) {
+    return CE.getArgSVal(0).getAsRegion();
+  } else if (FuncClassifier.isMPI_Waitall(CE.getCalleeIdentifier())) {
+    return CE.getArgSVal(1).getAsRegion();
+  } else {
+    return (const MemRegion *)nullptr;
+  }
+}
+
+void MPICheckerPathSensitive::allRegionsUsedByWait(
+    llvm::SmallVector<const MemRegion *, 2> &ReqRegions,
+    const MemRegion *const MR, const clang::ento::CallEvent &CE,
+    clang::ento::CheckerContext &Ctx) const {
+
+  MemRegionManager *const RegionManager = MR->getMemRegionManager();
+
+  if (FuncClassifier.isMPI_Waitall(CE.getCalleeIdentifier())) {
+    const MemRegion *SuperRegion{nullptr};
+    if (const ElementRegion *const ER = MR->getAs<ElementRegion>()) {
+      SuperRegion = ER->getSuperRegion();
+    }
+
+    // A single request is passed to MPI_Waitall.
+    if (!SuperRegion) {
+      ReqRegions.push_back(MR);
+      return;
+    }
+
+    const auto &size = Ctx.getStoreManager().getSizeInElements(
+        Ctx.getState(), SuperRegion,
+        CE.getArgExpr(1)->getType()->getPointeeType());
+    const llvm::APSInt &arrSize = size.getAs<nonloc::ConcreteInt>()->getValue();
+
+    for (size_t i = 0; i < arrSize; ++i) {
+      const NonLoc Idx = Ctx.getSValBuilder().makeArrayIndex(i);
+
+      const ElementRegion *const ER = RegionManager->getElementRegion(
+          CE.getArgExpr(1)->getType()->getPointeeType(), Idx, SuperRegion,
+          Ctx.getASTContext());
+
+      ReqRegions.push_back(ER->getAs<MemRegion>());
+    }
+  } else if (FuncClassifier.isMPI_Wait(CE.getCalleeIdentifier())) {
+    ReqRegions.push_back(MR);
+  }
+}
+
+} // end of namespace: mpi
+} // end of namespace: clang

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIFunctionClassifier.h

+//===-- MPIFunctionClassifier.h - classifies MPI functions ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines functionality to identify and classify MPI functions.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPIFUNCTIONCLASSIFIER_H
+#define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPIFUNCTIONCLASSIFIER_H
+
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+
+namespace clang {
+namespace mpi {
+
+class MPIFunctionClassifier {
+public:
+  MPIFunctionClassifier(clang::ento::AnalysisManager &AM) {
+    identifierInit(AM);
+  }
+
+  // general identifiers–––––––––––––––––––––––––––––––––––––––––––––––––
+  bool isMPIType(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isBlockingType(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isNonBlockingType(const clang::IdentifierInfo *const IdentInfo) const;
+
+  // point-to-point identifiers––––––––––––––––––––––––––––––––––––––––––
+  bool isPointToPointType(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isSendType(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isRecvType(const clang::IdentifierInfo *const IdentInfo) const;
+
+  // collective identifiers––––––––––––––––––––––––––––––––––––––––––––––
+  bool isCollectiveType(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isCollToColl(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isScatterType(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isGatherType(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isAllgatherType(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isAlltoallType(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isReduceType(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isBcastType(const clang::IdentifierInfo *const IdentInfo) const;
+
+  // additional identifiers ––––––––––––––––––––––––––––––––––––––––––––––
+  bool isMPI_Comm_rank(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isMPI_Comm_size(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isMPI_Wait(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isMPI_Waitall(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isMPI_Waitany(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isMPI_Waitsome(const clang::IdentifierInfo *const IdentInfo) const;
+  bool isWaitType(const clang::IdentifierInfo *const IdentInfo) const;
+
+private:
+  // Initializes function identifiers, to recognize them during analysis.
+  void identifierInit(clang::ento::AnalysisManager &AM);
+  void initPointToPointIdentifiers(clang::ento::AnalysisManager &AM);
+  void initCollectiveIdentifiers(clang::ento::AnalysisManager &AM);
+  void initAdditionalIdentifiers(clang::ento::AnalysisManager &AM);
+
+  // The containers are used, to enable classification of MPI-functions during
+  // analysis.
+  llvm::SmallVector<clang::IdentifierInfo *, 8> MPISendTypes;
+  llvm::SmallVector<clang::IdentifierInfo *, 2> MPIRecvTypes;
+
+  llvm::SmallVector<clang::IdentifierInfo *, 12> MPIBlockingTypes;
+  llvm::SmallVector<clang::IdentifierInfo *, 12> MPINonBlockingTypes;
+
+  llvm::SmallVector<clang::IdentifierInfo *, 10> MPIPointToPointTypes;
+  llvm::SmallVector<clang::IdentifierInfo *, 16> MPICollectiveTypes;
+
+  llvm::SmallVector<clang::IdentifierInfo *, 4> MPIPointToCollTypes;
+  llvm::SmallVector<clang::IdentifierInfo *, 4> MPICollToPointTypes;
+  llvm::SmallVector<clang::IdentifierInfo *, 6> MPICollToCollTypes;
+
+  llvm::SmallVector<clang::IdentifierInfo *, 32> MPIType;
+
+  // point-to-point functions
+  clang::IdentifierInfo *IdentInfo_MPI_Send{nullptr},
+      *IdentInfo_MPI_Isend{nullptr}, *IdentInfo_MPI_Ssend{nullptr},
+      *IdentInfo_MPI_Issend{nullptr}, *IdentInfo_MPI_Bsend{nullptr},
+      *IdentInfo_MPI_Ibsend{nullptr}, *IdentInfo_MPI_Rsend{nullptr},
+      *IdentInfo_MPI_Irsend{nullptr}, *IdentInfo_MPI_Recv{nullptr},
+      *IdentInfo_MPI_Irecv{nullptr};
+
+  // collective functions
+  clang::IdentifierInfo *IdentInfo_MPI_Scatter{nullptr},
+      *IdentInfo_MPI_Iscatter{nullptr}, *IdentInfo_MPI_Gather{nullptr},
+      *IdentInfo_MPI_Igather{nullptr}, *IdentInfo_MPI_Allgather{nullptr},
+      *IdentInfo_MPI_Iallgather{nullptr}, *IdentInfo_MPI_Bcast{nullptr},
+      *IdentInfo_MPI_Ibcast{nullptr}, *IdentInfo_MPI_Reduce{nullptr},
+      *IdentInfo_MPI_Ireduce{nullptr}, *IdentInfo_MPI_Allreduce{nullptr},
+      *IdentInfo_MPI_Iallreduce{nullptr}, *IdentInfo_MPI_Alltoall{nullptr},
+      *IdentInfo_MPI_Ialltoall{nullptr}, *IdentInfo_MPI_Barrier{nullptr};
+
+  // additional functions
+  clang::IdentifierInfo *IdentInfo_MPI_Comm_rank{nullptr},
+      *IdentInfo_MPI_Comm_size{nullptr}, *IdentInfo_MPI_Wait{nullptr},
+      *IdentInfo_MPI_Waitall{nullptr}, *IdentInfo_MPI_Waitany{nullptr},
+      *IdentInfo_MPI_Waitsome{nullptr};
+};
+
+} // end of namespace: mpi
+} // end of namespace: clang
+
+#endif

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIFunctionClassifier.cpp

+//===-- MPIFunctionClassifier.cpp - classifies MPI functions ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines functionality to identify and classify MPI functions.
+///
+//===----------------------------------------------------------------------===//
+
+#include "MPIFunctionClassifier.h"
+#include "Utility.h"
+#include "Container.h"
+
+namespace clang {
+namespace mpi {
+
+void MPIFunctionClassifier::identifierInit(clang::ento::AnalysisManager &AM) {
+  // Initialize function identifiers.
+  initPointToPointIdentifiers(AM);
+  initCollectiveIdentifiers(AM);
+  initAdditionalIdentifiers(AM);
+}
+
+void MPIFunctionClassifier::initPointToPointIdentifiers(
+    clang::ento::AnalysisManager &AM) {
+  ASTContext &ASTCtx = AM.getASTContext();
+
+  // Copy identifiers into the correct classification containers.
+  IdentInfo_MPI_Send = &ASTCtx.Idents.get("MPI_Send");
+  MPISendTypes.push_back(IdentInfo_MPI_Send);
+  MPIPointToPointTypes.push_back(IdentInfo_MPI_Send);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Send);
+  MPIType.push_back(IdentInfo_MPI_Send);
+  assert(IdentInfo_MPI_Send);
+
+  IdentInfo_MPI_Isend = &ASTCtx.Idents.get("MPI_Isend");
+  MPISendTypes.push_back(IdentInfo_MPI_Isend);
+  MPIPointToPointTypes.push_back(IdentInfo_MPI_Isend);
+  MPINonBlockingTypes.push_back(IdentInfo_MPI_Isend);
+  MPIType.push_back(IdentInfo_MPI_Isend);
+  assert(IdentInfo_MPI_Isend);
+
+  IdentInfo_MPI_Ssend = &ASTCtx.Idents.get("MPI_Ssend");
+  MPISendTypes.push_back(IdentInfo_MPI_Ssend);
+  MPIPointToPointTypes.push_back(IdentInfo_MPI_Ssend);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Ssend);
+  MPIType.push_back(IdentInfo_MPI_Ssend);
+  assert(IdentInfo_MPI_Ssend);
+
+  IdentInfo_MPI_Issend = &ASTCtx.Idents.get("MPI_Issend");
+  MPISendTypes.push_back(IdentInfo_MPI_Issend);
+  MPIPointToPointTypes.push_back(IdentInfo_MPI_Issend);
+  MPINonBlockingTypes.push_back(IdentInfo_MPI_Issend);
+  MPIType.push_back(IdentInfo_MPI_Issend);
+  assert(IdentInfo_MPI_Issend);
+
+  IdentInfo_MPI_Bsend = &ASTCtx.Idents.get("MPI_Bsend");
+  MPISendTypes.push_back(IdentInfo_MPI_Bsend);
+  MPIPointToPointTypes.push_back(IdentInfo_MPI_Bsend);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Bsend);
+  MPIType.push_back(IdentInfo_MPI_Bsend);
+  assert(IdentInfo_MPI_Bsend);
+
+  IdentInfo_MPI_Ibsend = &ASTCtx.Idents.get("MPI_Ibsend");
+  MPISendTypes.push_back(IdentInfo_MPI_Ibsend);
+  MPIPointToPointTypes.push_back(IdentInfo_MPI_Ibsend);
+  MPINonBlockingTypes.push_back(IdentInfo_MPI_Ibsend);
+  MPIType.push_back(IdentInfo_MPI_Ibsend);
+  assert(IdentInfo_MPI_Ibsend);
+
+  IdentInfo_MPI_Rsend = &ASTCtx.Idents.get("MPI_Rsend");
+  MPISendTypes.push_back(IdentInfo_MPI_Rsend);
+  MPIPointToPointTypes.push_back(IdentInfo_MPI_Rsend);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Rsend);
+  MPIType.push_back(IdentInfo_MPI_Rsend);
+  assert(IdentInfo_MPI_Rsend);
+
+  IdentInfo_MPI_Irsend = &ASTCtx.Idents.get("MPI_Irsend");
+  MPISendTypes.push_back(IdentInfo_MPI_Irsend);
+  MPIPointToPointTypes.push_back(IdentInfo_MPI_Irsend);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Irsend);
+  MPIType.push_back(IdentInfo_MPI_Irsend);
+  assert(IdentInfo_MPI_Irsend);
+
+  IdentInfo_MPI_Recv = &ASTCtx.Idents.get("MPI_Recv");
+  MPIRecvTypes.push_back(IdentInfo_MPI_Recv);
+  MPIPointToPointTypes.push_back(IdentInfo_MPI_Recv);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Recv);
+  MPIType.push_back(IdentInfo_MPI_Recv);
+  assert(IdentInfo_MPI_Recv);
+
+  IdentInfo_MPI_Irecv = &ASTCtx.Idents.get("MPI_Irecv");
+  MPIRecvTypes.push_back(IdentInfo_MPI_Irecv);
+  MPIPointToPointTypes.push_back(IdentInfo_MPI_Irecv);
+  MPINonBlockingTypes.push_back(IdentInfo_MPI_Irecv);
+  MPIType.push_back(IdentInfo_MPI_Irecv);
+  assert(IdentInfo_MPI_Irecv);
+}
+
+void MPIFunctionClassifier::initCollectiveIdentifiers(
+    clang::ento::AnalysisManager &AM) {
+  ASTContext &ASTCtx = AM.getASTContext();
+
+  // Copy identifiers into the correct classification containers.
+  IdentInfo_MPI_Scatter = &ASTCtx.Idents.get("MPI_Scatter");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Scatter);
+  MPIPointToCollTypes.push_back(IdentInfo_MPI_Scatter);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Scatter);
+  MPIType.push_back(IdentInfo_MPI_Scatter);
+  assert(IdentInfo_MPI_Scatter);
+
+  IdentInfo_MPI_Iscatter = &ASTCtx.Idents.get("MPI_Iscatter");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Iscatter);
+  MPIPointToCollTypes.push_back(IdentInfo_MPI_Iscatter);
+  MPINonBlockingTypes.push_back(IdentInfo_MPI_Iscatter);
+  MPIType.push_back(IdentInfo_MPI_Iscatter);
+  assert(IdentInfo_MPI_Iscatter);
+
+  IdentInfo_MPI_Gather = &ASTCtx.Idents.get("MPI_Gather");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Gather);
+  MPICollToPointTypes.push_back(IdentInfo_MPI_Gather);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Gather);
+  MPIType.push_back(IdentInfo_MPI_Gather);
+  assert(IdentInfo_MPI_Gather);
+
+  IdentInfo_MPI_Igather = &ASTCtx.Idents.get("MPI_Igather");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Igather);
+  MPICollToPointTypes.push_back(IdentInfo_MPI_Igather);
+  MPINonBlockingTypes.push_back(IdentInfo_MPI_Igather);
+  MPIType.push_back(IdentInfo_MPI_Igather);
+  assert(IdentInfo_MPI_Igather);
+
+  IdentInfo_MPI_Allgather = &ASTCtx.Idents.get("MPI_Allgather");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Allgather);
+  MPICollToCollTypes.push_back(IdentInfo_MPI_Allgather);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Allgather);
+  MPIType.push_back(IdentInfo_MPI_Allgather);
+  assert(IdentInfo_MPI_Allgather);
+
+  IdentInfo_MPI_Iallgather = &ASTCtx.Idents.get("MPI_Iallgather");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Iallgather);
+  MPICollToCollTypes.push_back(IdentInfo_MPI_Iallgather);
+  MPINonBlockingTypes.push_back(IdentInfo_MPI_Iallgather);
+  MPIType.push_back(IdentInfo_MPI_Iallgather);
+  assert(IdentInfo_MPI_Iallgather);
+
+  IdentInfo_MPI_Bcast = &ASTCtx.Idents.get("MPI_Bcast");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Bcast);
+  MPIPointToCollTypes.push_back(IdentInfo_MPI_Bcast);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Bcast);
+  MPIType.push_back(IdentInfo_MPI_Bcast);
+  assert(IdentInfo_MPI_Bcast);
+
+  IdentInfo_MPI_Ibcast = &ASTCtx.Idents.get("MPI_Ibcast");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Ibcast);
+  MPIPointToCollTypes.push_back(IdentInfo_MPI_Ibcast);
+  MPINonBlockingTypes.push_back(IdentInfo_MPI_Ibcast);
+  MPIType.push_back(IdentInfo_MPI_Ibcast);
+  assert(IdentInfo_MPI_Ibcast);
+
+  IdentInfo_MPI_Reduce = &ASTCtx.Idents.get("MPI_Reduce");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Reduce);
+  MPICollToPointTypes.push_back(IdentInfo_MPI_Reduce);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Reduce);
+  MPIType.push_back(IdentInfo_MPI_Reduce);
+  assert(IdentInfo_MPI_Reduce);
+
+  IdentInfo_MPI_Ireduce = &ASTCtx.Idents.get("MPI_Ireduce");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Ireduce);
+  MPICollToPointTypes.push_back(IdentInfo_MPI_Ireduce);
+  MPINonBlockingTypes.push_back(IdentInfo_MPI_Ireduce);
+  MPIType.push_back(IdentInfo_MPI_Ireduce);
+  assert(IdentInfo_MPI_Ireduce);
+
+  IdentInfo_MPI_Allreduce = &ASTCtx.Idents.get("MPI_Allreduce");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Allreduce);
+  MPICollToCollTypes.push_back(IdentInfo_MPI_Allreduce);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Allreduce);
+  MPIType.push_back(IdentInfo_MPI_Allreduce);
+  assert(IdentInfo_MPI_Allreduce);
+
+  IdentInfo_MPI_Iallreduce = &ASTCtx.Idents.get("MPI_Iallreduce");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Iallreduce);
+  MPICollToCollTypes.push_back(IdentInfo_MPI_Iallreduce);
+  MPINonBlockingTypes.push_back(IdentInfo_MPI_Iallreduce);
+  MPIType.push_back(IdentInfo_MPI_Iallreduce);
+  assert(IdentInfo_MPI_Iallreduce);
+
+  IdentInfo_MPI_Alltoall = &ASTCtx.Idents.get("MPI_Alltoall");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Alltoall);
+  MPICollToCollTypes.push_back(IdentInfo_MPI_Alltoall);
+  MPIBlockingTypes.push_back(IdentInfo_MPI_Alltoall);
+  MPIType.push_back(IdentInfo_MPI_Alltoall);
+  assert(IdentInfo_MPI_Alltoall);
+
+  IdentInfo_MPI_Ialltoall = &ASTCtx.Idents.get("MPI_Ialltoall");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Ialltoall);
+  MPICollToCollTypes.push_back(IdentInfo_MPI_Ialltoall);
+  MPINonBlockingTypes.push_back(IdentInfo_MPI_Ialltoall);
+  MPIType.push_back(IdentInfo_MPI_Ialltoall);
+  assert(IdentInfo_MPI_Ialltoall);
+}
+
+void MPIFunctionClassifier::initAdditionalIdentifiers(
+    clang::ento::AnalysisManager &AM) {
+  ASTContext &ASTCtx = AM.getASTContext();
+
+  IdentInfo_MPI_Comm_rank = &ASTCtx.Idents.get("MPI_Comm_rank");
+  MPIType.push_back(IdentInfo_MPI_Comm_rank);
+  assert(IdentInfo_MPI_Comm_rank);
+
+  IdentInfo_MPI_Comm_size = &ASTCtx.Idents.get("MPI_Comm_size");
+  MPIType.push_back(IdentInfo_MPI_Comm_size);
+  assert(IdentInfo_MPI_Comm_size);
+
+  IdentInfo_MPI_Wait = &ASTCtx.Idents.get("MPI_Wait");
+  MPIType.push_back(IdentInfo_MPI_Wait);
+  assert(IdentInfo_MPI_Wait);
+
+  IdentInfo_MPI_Waitall = &ASTCtx.Idents.get("MPI_Waitall");
+  MPIType.push_back(IdentInfo_MPI_Waitall);
+  assert(IdentInfo_MPI_Waitall);
+
+  IdentInfo_MPI_Waitany = &ASTCtx.Idents.get("MPI_Waitany");
+  MPIType.push_back(IdentInfo_MPI_Waitany);
+  assert(IdentInfo_MPI_Waitany);
+
+  IdentInfo_MPI_Waitsome = &ASTCtx.Idents.get("MPI_Waitsome");
+  MPIType.push_back(IdentInfo_MPI_Waitsome);
+  assert(IdentInfo_MPI_Waitsome);
+
+  IdentInfo_MPI_Barrier = &ASTCtx.Idents.get("MPI_Barrier");
+  MPICollectiveTypes.push_back(IdentInfo_MPI_Barrier);
+  MPIType.push_back(IdentInfo_MPI_Barrier);
+  assert(IdentInfo_MPI_Barrier);
+}
+
+// general identifiers–––––––––––––––––––––––––––––––––––––––––––––––––
+bool MPIFunctionClassifier::isMPIType(const IdentifierInfo *IdentInfo) const {
+  return cont::contains(MPIType, IdentInfo);
+}
+
+bool MPIFunctionClassifier::isBlockingType(
+    const IdentifierInfo *IdentInfo) const {
+  return cont::contains(MPIBlockingTypes, IdentInfo);
+}
+
+bool MPIFunctionClassifier::isNonBlockingType(
+    const IdentifierInfo *IdentInfo) const {
+  return cont::contains(MPINonBlockingTypes, IdentInfo);
+}
+
+// point-to-point identifiers––––––––––––––––––––––––––––––––––––––––––
+bool MPIFunctionClassifier::isPointToPointType(
+    const IdentifierInfo *IdentInfo) const {
+  return cont::contains(MPIPointToPointTypes, IdentInfo);
+}
+
+bool MPIFunctionClassifier::isSendType(const IdentifierInfo *IdentInfo) const {
+  return cont::contains(MPISendTypes, IdentInfo);
+}
+
+bool MPIFunctionClassifier::isRecvType(const IdentifierInfo *IdentInfo) const {
+  return cont::contains(MPIRecvTypes, IdentInfo);
+}
+
+// collective identifiers––––––––––––––––––––––––––––––––––––––––––––––
+bool MPIFunctionClassifier::isCollectiveType(
+    const IdentifierInfo *IdentInfo) const {
+  return cont::contains(MPICollectiveTypes, IdentInfo);
+}
+
+bool MPIFunctionClassifier::isCollToColl(
+    const IdentifierInfo *IdentInfo) const {
+  return cont::contains(MPICollToCollTypes, IdentInfo);
+}
+
+bool MPIFunctionClassifier::isScatterType(
+    const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Scatter ||
+         IdentInfo == IdentInfo_MPI_Iscatter;
+}
+
+bool MPIFunctionClassifier::isGatherType(
+    const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Gather ||
+         IdentInfo == IdentInfo_MPI_Igather ||
+         IdentInfo == IdentInfo_MPI_Allgather ||
+         IdentInfo == IdentInfo_MPI_Iallgather;
+}
+
+bool MPIFunctionClassifier::isAllgatherType(
+    const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Allgather ||
+         IdentInfo == IdentInfo_MPI_Iallgather;
+}
+
+bool MPIFunctionClassifier::isAlltoallType(
+    const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Alltoall ||
+         IdentInfo == IdentInfo_MPI_Ialltoall;
+}
+
+bool MPIFunctionClassifier::isBcastType(const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Bcast || IdentInfo == IdentInfo_MPI_Ibcast;
+}
+
+bool MPIFunctionClassifier::isReduceType(
+    const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Reduce ||
+         IdentInfo == IdentInfo_MPI_Ireduce ||
+         IdentInfo == IdentInfo_MPI_Allreduce ||
+         IdentInfo == IdentInfo_MPI_Iallreduce;
+}
+
+// additional identifiers ––––––––––––––––––––––––––––––––––––––––––––––
+bool MPIFunctionClassifier::isMPI_Comm_rank(
+    const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Comm_rank;
+}
+
+bool MPIFunctionClassifier::isMPI_Comm_size(
+    const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Comm_size;
+}
+
+bool MPIFunctionClassifier::isMPI_Wait(const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Wait;
+}
+
+bool MPIFunctionClassifier::isMPI_Waitall(
+    const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Waitall;
+}
+
+bool MPIFunctionClassifier::isMPI_Waitany(
+    const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Waitany;
+}
+
+bool MPIFunctionClassifier::isMPI_Waitsome(
+    const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Waitsome;
+}
+
+bool MPIFunctionClassifier::isWaitType(const IdentifierInfo *IdentInfo) const {
+  return IdentInfo == IdentInfo_MPI_Wait ||
+         IdentInfo == IdentInfo_MPI_Waitall ||
+         IdentInfo == IdentInfo_MPI_Waitany ||
+         IdentInfo == IdentInfo_MPI_Waitsome;
+}
+
+} // end of namespace: mpi
+} // end of namespace: clang

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

+//===-- MPITypes.h - Functionality to model MPI concepts --------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file provides definitions, to model the schema of MPI point-to-point
+/// functions and MPI requests. The mpi::Request class defines a wrapper
+/// class, in order to make MPI requests trackable for path-sensitive analysis.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPITYPES_H
+#define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPITYPES_H
+
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "llvm/ADT/SmallSet.h"
+#include "MPIFunctionClassifier.h"
+#include "Utility.h"
+#include "Container.h"
+
+// for path-sensitive analysis–––––––––––––––––––––––––––––––––––––––––––––––
+namespace clang {
+namespace ento {
+namespace mpi {
+
+class Request {
+public:
+  enum State : unsigned char { Null, Undefined, Nonblocking, Wait };
+
+  Request(State UT) : CurrentState{UT} {}
+
+  void Profile(llvm::FoldingSetNodeID &Id) const {
+    Id.AddInteger(CurrentState);
+  }
+
+  bool operator==(const Request &ToCompare) const {
+    return CurrentState == ToCompare.CurrentState;
+  }
+
+  const State CurrentState;
+};
+
+} // end of namespace: mpi
+} // end of namespace: ento
+} // end of namespace: clang
+
+// Data structure for path-sensitive analysis. The map stores MPI
+// requests which are identified by their memory region. Requests are used in
+// MPI to complete nonblocking operations with wait operations. Requests can be
+// used as part of an array.
+struct RequestMap {};
+typedef llvm::ImmutableMap<const clang::ento::MemRegion *,
+                           clang::ento::mpi::Request> RequestMapImpl;
+template <>
+struct clang::ento::ProgramStateTrait<RequestMap>
+    : public clang::ento::ProgramStatePartialTrait<RequestMapImpl> {
+  static void *GDMIndex() {
+    static int index = 0;
+    return &index;
+  }
+};
+
+// argument schema enums ––––––––––––––––––––––––––––––––––––––––––––––––––––
+namespace clang {
+namespace mpi {
+// Scope enums but keep weak typing, to make values usable as indices.
+
+// Represents argument schema for MPI point-to-point functions.
+// The existence and type of last argument must be checked dynamically.
+namespace MPIPointToPoint {
+enum { Buf, Count, Datatype, Rank, Tag, Comm, Request };
+}
+} // end of namespace: mpi
+} // end of namespace: clang
+
+#endif

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/TranslationUnitVisitor.h

+//===-- TranslationUnitVisitor.h - traverses tu --*---------------- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines a translation unit visitor class that invokes
+/// AST-based checks on an MPICheckerAST instance during traversal.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_TRANSLATIONUNITVISITOR_H
+#define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_TRANSLATIONUNITVISITOR_H
+
+#include "MPICheckerAST.h"
+
+namespace clang {
+namespace mpi {
+
+class TranslationUnitVisitor
+    : public clang::RecursiveASTVisitor<TranslationUnitVisitor> {
+public:
+  TranslationUnitVisitor(clang::ento::BugReporter &BR,
+                         const clang::ento::CheckerBase &CB,
+                         clang::ento::AnalysisManager &AM)
+      : CheckerAST{BR, CB, AM}, FuncClassifier{AM} {}
+
+  // Visited for each function declaration.
+  bool VisitFunctionDecl(clang::FunctionDecl *FuncDecl);
+
+  // Visited for each call expression.
+  bool VisitCallExpr(clang::CallExpr *CE);
+
+  MPICheckerAST CheckerAST;
+  MPIFunctionClassifier FuncClassifier;
+};
+
+} // end of namespace: mpi
+} // end of namespace: clang
+
+#endif

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/TranslationUnitVisitor.cpp

+//===-- TranslationUnitVisitor.cpp - traverses tu --*-------------- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines a translation unit visitor class that invokes
+/// AST-based checks on an MPICheckerAST instance during traversal.
+///
+//===----------------------------------------------------------------------===//
+
+#include "TranslationUnitVisitor.h"
+#include "MPICheckerPathSensitive.h"
+
+namespace clang {
+namespace mpi {
+
+bool TranslationUnitVisitor::VisitFunctionDecl(FunctionDecl *FuncDecl) {
+  // to keep track which function implementation is currently analysed
+  if (FuncDecl->clang::Decl::hasBody() && !FuncDecl->isInlined()) {
+    // to make display of function in diagnostics available
+    CheckerAST.setCurrentlyVisitedFunction(FuncDecl);
+  }
+  return true;
+}
+
+bool TranslationUnitVisitor::VisitCallExpr(clang::CallExpr *CE) {
+  if (FuncClassifier.isMPIType(util::getIdentInfo(CE))) {
+    CheckerAST.checkBufferTypeMatch(CE);
+    CheckerAST.checkForInvalidArgs(CE);
+  }
+
+  return true;
+}
+
+} // end of namespace: mpi
+} // end of namespace: clang

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/TypeVisitor.h

+//===-- TypeVisitor - traverse qual type ------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines a type visitor class which collects information about the
+//  QualType instance passed to its ctor. It detects if the QualType is a
+/// typedef, complex type, builtin type and the pointer count.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_TYPEVISITOR_H
+#define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_TYPEVISITOR_H
+
+#include "clang/AST/RecursiveASTVisitor.h"
+
+namespace clang {
+namespace mpi {
+
+class TypeVisitor : public clang::RecursiveASTVisitor<TypeVisitor> {
+public:
+  TypeVisitor(clang::QualType TypeToInspect) : InspectedType{TypeToInspect} {
+    TraverseType(TypeToInspect);
+
+    // Dereference pointers and remove qualifiers.
+    DerefUnqualType = TypeToInspect;
+    while (DerefUnqualType->isPointerType()) {
+      DerefUnqualType = DerefUnqualType->getPointeeType();
+    }
+    DerefUnqualType = DerefUnqualType.getUnqualifiedType();
+  }
+
+  bool VisitTypedefType(clang::TypedefType *TDT) {
+    TypedefTypeName = TDT->getDecl()->getQualifiedNameAsString();
+    IsTypedefType = true;
+    return true;
+  }
+
+  bool VisitBuiltinType(clang::BuiltinType *BT) {
+    BuiltinType = BT;
+    return true;
+  }
+
+  bool VisitComplexType(clang::ComplexType *) {
+    IsComplexCType = true;
+    return true;
+  }
+
+  bool VisitTemplateSpecializationType(clang::TemplateSpecializationType *TST) {
+    TemplateName = TST->getAsCXXRecordDecl()->getNameAsString();
+    TemplateSpecializationType = TST;
+    return true;
+  }
+
+  bool VisitPointerType(clang::PointerType *) {
+    ++PointerCount;
+    return true;
+  }
+
+  bool VisitArrayType(clang::ArrayType *) {
+    ++PointerCount;
+    return true;
+  }
+
+  // passed qual type
+  const clang::QualType InspectedType;
+
+  bool isTypedefType() const { return IsTypedefType; }
+  bool isComplexCType() const { return IsComplexCType; }
+  const std::string typedefTypeName() const & { return TypedefTypeName; }
+  const std::string templateName() const & { return TemplateName; }
+  size_t pointerCount() const { return PointerCount; }
+  const clang::BuiltinType *builtinType() const { return BuiltinType; }
+  const clang::TemplateSpecializationType *templateType() const {
+    return TemplateSpecializationType;
+  }
+  const clang::QualType derefUnqualType() const { return DerefUnqualType; }
+
+private:
+  bool IsTypedefType{false};
+  bool IsComplexCType{false};
+  std::string TypedefTypeName;
+  std::string TemplateName;
+  size_t PointerCount{0};
+
+  clang::QualType DerefUnqualType;
+  clang::TemplateSpecializationType *TemplateSpecializationType = nullptr;
+  clang::BuiltinType *BuiltinType = nullptr;
+};
+
+} // end of namespace: mpi
+} // end of namespace: clang
+
+#endif

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Utility.h

+//===-- Utility.h - utility functions ---------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines utility helper functions for MPI-Checker.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_UTILITY_H
+#define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_UTILITY_H
+
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+
+namespace util {
+
+/// Retrieve source range from memory region. The range retrieval
+/// is based on the decl obtained from the memory region.
+/// For a VarRegion the range of the base region is returned.
+/// For a FieldRegion the range of the field is returned.
+/// If no declaration is found, an empty source range is returned.
+/// The client is responsible for checking if the returned range is valid.
+///
+/// \param MR memory region to retrieve the source range for
+///
+/// \returns source range for declaration retrieved from memory region
+clang::SourceRange sourceRange(const clang::ento::MemRegion *MR);
+
+/// Returns the source range \p Range as a StringRef.
+clang::StringRef sourceRangeAsStringRef(const clang::SourceRange &Range,
+                                        clang::ento::AnalysisManager &AM);
+
+/// Retrieve identifier info for a call expression.
+/// Returns nullptr if there's no direct callee.
+///
+/// \param CE call expression to retrieve ident info for
+///
+/// \returns identifier info for passed call expression
+const clang::IdentifierInfo *getIdentInfo(const clang::CallExpr *CE);
+
+/// Get variable name for memory region. The name is obtained from
+/// the variable/field declaration retrieved from the memory region.
+/// Regions that point to an element of an array are returned as: "arr[0]".
+/// Regions that point to a struct are returned as: "st.var".
+///
+/// \param MR memory region to get the variable name for
+///
+/// \returns variable name for memory region
+std::string variableName(const clang::ento::MemRegion *MR);
+
+} // end of namespace: util
+
+#endif

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/Utility.cpp

+//===-- Utility.cpp - utility functions -------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines utility helper functions for MPI-Checker.
+///
+//===----------------------------------------------------------------------===//
+
+#include "clang/Lex/Lexer.h"
+#include "clang/StaticAnalyzer/Core/CheckerManager.h"
+#include "Utility.h"
+#include <sstream>
+#include <vector>
+
+namespace util {
+
+clang::SourceRange sourceRange(const clang::ento::MemRegion *MR) {
+  const clang::ento::VarRegion *VR =
+      clang::dyn_cast<clang::ento::VarRegion>(MR->getBaseRegion());
+
+  const clang::ento::FieldRegion *FR =
+      clang::dyn_cast<clang::ento::FieldRegion>(MR);
+
+  if (FR) {
+    return FR->getDecl()->getSourceRange();
+  } else if (VR) {
+    return VR->getDecl()->getSourceRange();
+  } else {
+    // non valid source range (can be checked by client)
+    return clang::SourceRange{};
+  }
+}
+
+clang::StringRef sourceRangeAsStringRef(const clang::SourceRange &Range,
+                                        clang::ento::AnalysisManager &AM) {
+  auto CharRange = clang::CharSourceRange::getTokenRange(Range);
+  return clang::Lexer::getSourceText(CharRange, AM.getSourceManager(),
+                                     clang::LangOptions());
+}
+
+std::string variableName(const clang::ento::MemRegion *MR) {
+  std::string VariableName{""};
+  std::string ArrayIndices{""};
+
+  const clang::ento::MemRegion *R = MR;
+  llvm::SmallString<200> buf;
+  llvm::raw_svector_ostream os(buf);
+
+  // Obtain array indices to add them to the variable name.
+  const clang::ento::ElementRegion *ER = nullptr;
+  while ((ER = R->getAs<clang::ento::ElementRegion>())) {
+    llvm::APSInt IndexInArray =
+        ER->getIndex().getAs<clang::ento::nonloc::ConcreteInt>()->getValue();
+
+    llvm::SmallString<2> intValAsString;
+    IndexInArray.toString(intValAsString);
+    std::string idx{intValAsString.begin(), intValAsString.end()};
+
+    ArrayIndices = "[" + idx + "]" + ArrayIndices;
+
+    R = R->getAs<clang::ento::ElementRegion>()->getSuperRegion();
+  }
+
+  // Get variable name.
+  if (R && R->canPrintPretty()) {
+    R->printPretty(os);
+    VariableName += os.str();
+  }
+
+  // Combine variable with indices.
+  if (VariableName.back() == '\'') {
+    VariableName.insert(VariableName.size() - 1, ArrayIndices);
+  } else {
+    VariableName += ArrayIndices;
+  }
+
+  return VariableName;
+}
+
+const clang::IdentifierInfo *getIdentInfo(const clang::CallExpr *CE) {
+  if (CE->getDirectCallee()) {
+    return CE->getDirectCallee()->getIdentifier();
+  } else {
+    return nullptr;
+  }
+}
+
+} // end of namespace: util

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/test/Analysis/MPIChecker.cpp

+// RUN: %clang_cc1 -analyze -analyzer-checker=mpi.MPI-Checker -verify %s
+
+// MPI-Checker makes no assumptions about details of an MPI implementation.
+// Typedefs and constants are compared as strings.
+
+#define NULL 0
+
+// mock types
+typedef int MPI_Datatype;
+typedef int MPI_Comm;
+typedef int MPI_Request;
+typedef int MPI_Status;
+typedef int MPI_Op;
+typedef int int8_t;
+typedef int uint8_t;
+typedef int uint16_t;
+typedef int int64_t;
+namespace std { template<class T> struct complex { T real; T imag; }; }
+
+// mock constants
+#define MPI_DATATYPE_NULL 0
+#define MPI_CHAR 0
+#define MPI_BYTE 0
+#define MPI_INT 0
+#define MPI_LONG 0
+#define MPI_LONG_DOUBLE 0
+#define MPI_UNSIGNED 0
+#define MPI_INT8_T 0
+#define MPI_UINT8_T 0
+#define MPI_UINT16_T 0
+#define MPI_C_LONG_DOUBLE_COMPLEX 0
+#define MPI_FLOAT 0
+#define MPI_DOUBLE 0
+#define MPI_CXX_BOOL 0
+#define MPI_CXX_FLOAT_COMPLEX 0
+#define MPI_CXX_DOUBLE_COMPLEX 0
+#define MPI_CXX_LONG_DOUBLE_COMPLEX 0
+#define MPI_IN_PLACE 0
+#define MPI_COMM_WORLD 0
+#define MPI_STATUS_IGNORE 0
+#define MPI_STATUSES_IGNORE 0
+#define MPI_SUM 0
+
+int MPI_Comm_size(MPI_Comm, int *);
+int MPI_Comm_rank(MPI_Comm, int *);
+int MPI_Send(const void *, int, MPI_Datatype, int, int, MPI_Comm);
+int MPI_Recv(void *, int, MPI_Datatype, int, int, MPI_Comm, MPI_Status *);
+int MPI_Isend(const void *, int, MPI_Datatype, int, int, MPI_Comm,
+    MPI_Request *);
+int MPI_Irecv(void *, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *);
+int MPI_Wait(MPI_Request *, MPI_Status *);
+int MPI_Waitall(int, MPI_Request[], MPI_Status[]);
+int MPI_Reduce(const void *, void *, int, MPI_Datatype, MPI_Op, int, MPI_Comm);
+int MPI_Ireduce(const void *, void *, int, MPI_Datatype, MPI_Op, int, MPI_Comm,
+    MPI_Request *);
+int MPI_Bcast(void *, int count, MPI_Datatype, int, MPI_Comm);
+
+//integration tests-------------------------------------------------------
+
+void matchedWait1() {
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank >= 0) {
+    MPI_Request sendReq1, recvReq1;
+    MPI_Isend(&buf, 1, MPI_DOUBLE, rank + 1, 3, MPI_COMM_WORLD, &sendReq1);
+    MPI_Irecv(&buf, 1, MPI_DOUBLE, rank - 1, 3, MPI_COMM_WORLD, &recvReq1);
+
+    MPI_Wait(&sendReq1, MPI_STATUS_IGNORE);
+    MPI_Wait(&recvReq1, MPI_STATUS_IGNORE);
+  }
+} // no error
+
+void matchedWait2() {
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank >= 0) {
+    MPI_Request sendReq1, recvReq1;
+    MPI_Isend(&buf, 1, MPI_DOUBLE, rank + 1, 4, MPI_COMM_WORLD, &sendReq1);
+    MPI_Irecv(&buf, 1, MPI_DOUBLE, rank - 1, 4, MPI_COMM_WORLD, &recvReq1);
+    MPI_Wait(&sendReq1, MPI_STATUS_IGNORE);
+    MPI_Wait(&recvReq1, MPI_STATUS_IGNORE);
+  }
+} // no error
+
+void matchedWait3() {
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank >= 0) {
+    MPI_Request sendReq1, recvReq1;
+    MPI_Isend(&buf, 1, MPI_DOUBLE, rank + 1, 5, MPI_COMM_WORLD, &sendReq1);
+    MPI_Irecv(&buf, 1, MPI_DOUBLE, rank - 1, 5, MPI_COMM_WORLD, &recvReq1);
+
+    if (rank > 1000) {
+      MPI_Wait(&sendReq1, MPI_STATUS_IGNORE);
+      MPI_Wait(&recvReq1, MPI_STATUS_IGNORE);
+    } else {
+      MPI_Wait(&sendReq1, MPI_STATUS_IGNORE);
+      MPI_Wait(&recvReq1, MPI_STATUS_IGNORE);
+    }
+  }
+} // no error
+
+void missingWait1() {
+  int rank = 0;
+  double buf = 0;
+  MPI_Request sendReq1;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD,
+              &sendReq1); // Request is previously used by nonblocking call here.
+} // expected-warning{{Request 'sendReq1' has no matching wait.}}
+
+void missingWait3() {
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank == 0) {
+  } else {
+    MPI_Request sendReq1, recvReq1;
+
+    MPI_Isend(&buf, 1, MPI_DOUBLE, rank + 1, 2, MPI_COMM_WORLD, &sendReq1); // Request is previously used by nonblocking call here.
+    MPI_Irecv(&buf, 1, MPI_DOUBLE, rank - 1, 2, MPI_COMM_WORLD, &recvReq1); // expected-warning{{Request 'sendReq1' has no matching wait.}}
+    MPI_Wait(&recvReq1, MPI_STATUS_IGNORE);
+  }
+}
+
+void doubleNonblocking() {
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank == 1) {
+  } else {
+    MPI_Request sendReq1;
+
+    MPI_Isend(&buf, 1, MPI_DOUBLE, rank + 1, 6, MPI_COMM_WORLD, &sendReq1); // Request is previously used by nonblocking call here.
+    MPI_Irecv(&buf, 1, MPI_DOUBLE, rank - 1, 6, MPI_COMM_WORLD, &sendReq1); // expected-warning{{Double nonblocking on request 'sendReq1'.}}
+    MPI_Wait(&sendReq1, MPI_STATUS_IGNORE);
+  }
+}
+
+void doubleNonblocking2() {
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  MPI_Request req;
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD, &req); //Request is previously used by nonblocking call here.
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD, &req); // expected-warning{{Double nonblocking on request 'req'.}}
+  MPI_Wait(&req, MPI_STATUS_IGNORE);
+}
+
+void doubleNonblocking3() {
+  typedef struct { MPI_Request req; } ReqStruct;
+
+  ReqStruct rs;
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD, &rs.req); //  Request is previously used by nonblocking call here.
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD, &rs.req); // expected-warning{{Double nonblocking on request 'rs.req'.}}
+  MPI_Wait(&rs.req, MPI_STATUS_IGNORE);
+}
+
+void doubleNonblocking4() {
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  MPI_Request req;
+  for (int i = 0; i < 2; ++i) {
+    MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD, &req); // expected-warning{{Double nonblocking on request 'req'.}}
+  }
+  MPI_Wait(&req, MPI_STATUS_IGNORE);
+}
+
+void missingNonBlocking() {
+  int rank = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Request sendReq1;
+  MPI_Wait(&sendReq1, MPI_STATUS_IGNORE); // expected-warning{{Request 'sendReq1' has no matching nonblocking call.}}
+}
+
+void noDoubleRequestUsage() {
+  typedef struct {
+    MPI_Request req;
+    MPI_Request req2;
+  } ReqStruct;
+
+  ReqStruct rs;
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD,
+              &rs.req);
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD,
+              &rs.req2);
+  MPI_Wait(&rs.req, MPI_STATUS_IGNORE);
+  MPI_Wait(&rs.req2, MPI_STATUS_IGNORE);
+}
+
+void noDoubleRequestUsage2() {
+  typedef struct {
+    MPI_Request req[2];
+    MPI_Request req2;
+  } ReqStruct;
+
+  ReqStruct rs;
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD,
+              &rs.req[0]);
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD,
+              &rs.req[1]);
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD,
+              &rs.req2);
+  MPI_Wait(&rs.req[0], MPI_STATUS_IGNORE);
+  MPI_Wait(&rs.req[1], MPI_STATUS_IGNORE);
+  MPI_Wait(&rs.req2, MPI_STATUS_IGNORE);
+}
+
+void nestedRequest() {
+  typedef struct {
+    MPI_Request req[2];
+    MPI_Request req2;
+  } ReqStruct;
+
+  ReqStruct rs;
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD,
+              &rs.req[0]);
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD,
+              &rs.req[1]);
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD,
+              &rs.req2);
+  MPI_Waitall(2, rs.req, MPI_STATUSES_IGNORE);
+  MPI_Wait(&rs.req2, MPI_STATUS_IGNORE);
+}
+
+void singleRequestInWaitall() {
+  MPI_Request r;
+  int rank = 0;
+  double buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD,
+              &r);
+  MPI_Waitall(1, &r, MPI_STATUSES_IGNORE);
+}
+
+void typeMatching1() {
+  double buf = 0;
+  double *bufP = &buf;
+  int rank = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  if (rank == 0) {
+    MPI_Send(&buf, 1, MPI_FLOAT, rank + 1, 7, MPI_COMM_WORLD); // expected-warning{{Buffer type 'double' and specified MPI type 'MPI_FLOAT' do not match.}}
+  } else {
+    MPI_Recv(bufP, 1, MPI_FLOAT, rank - 1, 7, MPI_COMM_WORLD, MPI_STATUS_IGNORE); // expected-warning{{Buffer type 'double' and specified MPI type 'MPI_FLOAT' do not match.}}
+  }
+
+  if (rank == 0) {
+    MPI_Send(&buf, 1, MPI_DOUBLE, rank + 1, 7, MPI_COMM_WORLD);
+  } else {
+    MPI_Recv(bufP, 1, MPI_DOUBLE, rank - 1, 7, MPI_COMM_WORLD,
+             MPI_STATUS_IGNORE);
+  }
+}
+
+void typeMatching2() {
+  int buf = 0;
+  int *bufP = &buf;
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_CHAR, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type 'int' and specified MPI type 'MPI_CHAR' do not match.}}
+  MPI_Reduce(MPI_IN_PLACE, bufP, 1, MPI_CHAR, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type 'int' and specified MPI type 'MPI_CHAR' do not match.}}
+
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
+  MPI_Reduce(MPI_IN_PLACE, bufP, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
+}
+
+void typeMatching3() {
+  long double buf = 11;
+  const long double *const bufP = &buf;
+  int rank = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank == 0) {
+    MPI_Send(bufP, 1, MPI_DOUBLE, rank + 1, 8, MPI_COMM_WORLD); // expected-warning{{Buffer type 'long double' and specified MPI type 'MPI_DOUBLE' do not match.}}
+  } else {
+    MPI_Recv(&buf, 1, MPI_DOUBLE, rank - 1, 8, MPI_COMM_WORLD, MPI_STATUS_IGNORE); // expected-warning{{Buffer type 'long double' and specified MPI type 'MPI_DOUBLE' do not match.}}
+  }
+
+  if (rank == 0) {
+    MPI_Send(bufP, 1, MPI_LONG_DOUBLE, rank + 1, 8, MPI_COMM_WORLD);
+  } else {
+    MPI_Recv(&buf, 1, MPI_LONG_DOUBLE, rank - 1, 8, MPI_COMM_WORLD,
+             MPI_STATUS_IGNORE);
+  }
+}
+
+void typeMatching4() {
+  long double _Complex buf = 11;
+  long double _Complex *bufP = &buf;
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type '_Complex long double' and specified MPI type 'MPI_DOUBLE' do not match.}}
+  MPI_Reduce(MPI_IN_PLACE, bufP, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type '_Complex long double' and specified MPI type 'MPI_DOUBLE' do not match.}}
+
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_C_LONG_DOUBLE_COMPLEX, MPI_SUM, 0,
+             MPI_COMM_WORLD);
+  MPI_Reduce(MPI_IN_PLACE, bufP, 1, MPI_C_LONG_DOUBLE_COMPLEX, MPI_SUM, 0,
+             MPI_COMM_WORLD);
+}
+
+void typeMatching5() {
+  int64_t buf = 11;
+  const int64_t *const bufP = &buf;
+  int rank = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank == 0) {
+    MPI_Send(bufP, 1, MPI_INT, rank + 1, 9, MPI_COMM_WORLD); // expected-warning{{Buffer type 'int64_t' and specified MPI type 'MPI_INT' do not match.}}
+  } else {
+    MPI_Recv(&buf, 1, MPI_INT, rank - 1, 9, MPI_COMM_WORLD, MPI_STATUS_IGNORE); // expected-warning{{Buffer type 'int64_t' and specified MPI type 'MPI_INT' do not match.}}
+  }
+}
+
+void typeMatching6() {
+  uint8_t buf = 11;
+  uint8_t *bufP = &buf;
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_UNSIGNED, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type 'uint8_t' and specified MPI type 'MPI_UNSIGNED' do not match.}}
+  MPI_Reduce(MPI_IN_PLACE, bufP, 1, MPI_UNSIGNED, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type 'uint8_t' and specified MPI type 'MPI_UNSIGNED' do not match.}}
+
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_UINT8_T, MPI_SUM, 0, MPI_COMM_WORLD);
+  MPI_Reduce(MPI_IN_PLACE, bufP, 1, MPI_UINT8_T, MPI_SUM, 0, MPI_COMM_WORLD);
+}
+
+void typeMatching7() {
+  uint8_t buf = 11;
+  const uint8_t *const bufP = &buf;
+
+  int rank = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  if (rank == 0) {
+    MPI_Send(bufP, 1, MPI_UINT16_T, rank + 1, 10, MPI_COMM_WORLD); // expected-warning{{Buffer type 'uint8_t' and specified MPI type 'MPI_UINT16_T' do not match.}}
+  } else {
+    MPI_Recv(&buf, 1, MPI_UINT16_T, rank - 1, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE); // expected-warning{{Buffer type 'uint8_t' and specified MPI type 'MPI_UINT16_T' do not match.}}
+  }
+
+  if (rank == 0) {
+    MPI_Send(bufP, 1, MPI_UINT8_T, rank + 1, 10, MPI_COMM_WORLD);
+  } else {
+    MPI_Recv(&buf, 1, MPI_UINT8_T, rank - 1, 10, MPI_COMM_WORLD,
+             MPI_STATUS_IGNORE);
+  }
+}
+
+void typeMatching8() {
+  uint8_t buf = 11;
+  uint8_t *bufP = &buf;
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_INT8_T, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type 'uint8_t' and specified MPI type 'MPI_INT8_T' do not match.}}
+  MPI_Reduce(MPI_IN_PLACE, bufP, 1, MPI_INT8_T, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type 'uint8_t' and specified MPI type 'MPI_INT8_T' do not match.}}
+
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_UINT8_T, MPI_SUM, 0, MPI_COMM_WORLD);
+  MPI_Reduce(MPI_IN_PLACE, bufP, 1, MPI_UINT8_T, MPI_SUM, 0, MPI_COMM_WORLD);
+}
+
+void typeMatching9() {
+  char buf = 'a';
+  char *bufP = &buf;
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type 'char' and specified MPI type 'MPI_INT' do not match.}}
+  MPI_Reduce(MPI_IN_PLACE, bufP, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type 'char' and specified MPI type 'MPI_INT' do not match.}}
+
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_CHAR, MPI_SUM, 0, MPI_COMM_WORLD);
+  MPI_Reduce(MPI_IN_PLACE, bufP, 1, MPI_CHAR, MPI_SUM, 0, MPI_COMM_WORLD);
+}
+
+void typeMatching10() {
+  struct a {
+    int x;
+  } buf;
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
+} // no error, checker does not verify structs
+
+void typeMatching11() {
+  float ***buf = NULL;
+  MPI_Reduce(MPI_IN_PLACE, **buf, 1, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD);
+} // no error
+
+void typeMatching12() {
+  typedef int Int;
+  Int buf = 1;
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_CHAR, MPI_SUM, 0, MPI_COMM_WORLD);
+} // no error, checker makes no assumptions about typedefs
+
+void typeMatching13() {
+  long buf = 0;
+  MPI_Reduce(MPI_IN_PLACE, &buf, 8, MPI_BYTE, MPI_SUM, 0, MPI_COMM_WORLD);
+} // no error, checker does not verify MPI_BYTE
+
+void typeMatching14() {
+  float ***buf = NULL;
+  MPI_Reduce(MPI_IN_PLACE, buf, 1, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer is not correctly dereferenced. It is passed as a *** pointer.}}
+} // buffer type not correctly dereferenced
+
+void typeMatching15() {
+  float *buf = NULL;
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer is not correctly dereferenced. It is passed as a ** pointer.}}
+} // buffer type is float **
+
+void typeMatching16() {
+  float ***buf = NULL;
+  MPI_Reduce(MPI_IN_PLACE, *buf, 1, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer is not correctly dereferenced. It is passed as a ** pointer.}}
+} // buffer type not correctly dereferenced
+
+void typeMatching17() {
+  float buf[2];
+  MPI_Reduce(MPI_IN_PLACE, buf, 2, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD);
+}
+
+void typeMatching18() {
+  float *buf[2];
+  MPI_Reduce(MPI_IN_PLACE, buf, 2, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer is not correctly dereferenced. It is passed as a ** pointer.}}
+}
+
+void typeMatching19() {
+  float buf[2];
+  MPI_Reduce(MPI_IN_PLACE, &buf, 2, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer is not correctly dereferenced. It is passed as a ** pointer.}}
+}
+
+void typeMatching20() {
+  float *buf = NULL;
+  MPI_Reduce(MPI_IN_PLACE, &buf[0], 1, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD);
+  MPI_Bcast(&buf[0], 21, MPI_FLOAT, 0, MPI_COMM_WORLD);
+}
+
+void typeMatching21() {
+  bool *buf = NULL;
+  MPI_Reduce(MPI_IN_PLACE, buf, 1, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type '_Bool' and specified MPI type 'MPI_FLOAT' do not match.}}
+  MPI_Reduce(MPI_IN_PLACE, buf, 1, MPI_CXX_BOOL, MPI_SUM, 0, MPI_COMM_WORLD);
+}
+
+void typeMatching22() {
+  std::complex<double> buf;
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type 'std::complex<double>' and specified MPI type 'MPI_DOUBLE' do not match.}}
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_CXX_FLOAT_COMPLEX, MPI_SUM, 0, MPI_COMM_WORLD); // expected-warning{{Buffer type 'std::complex<double>' and specified MPI type 'MPI_CXX_FLOAT_COMPLEX' do not match.}}
+  MPI_Reduce(MPI_IN_PLACE, &buf, 1, MPI_CXX_DOUBLE_COMPLEX, MPI_SUM, 0, MPI_COMM_WORLD);
+}
+
+void invalidArgType() {
+  int rank = 0;
+  int buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank == 0) {
+    MPI_Send(&buf, 1, MPI_INT, rank + 1.1, 11, MPI_COMM_WORLD); // expected-warning{{The type, argument at index 3 evaluates to, is not an integer type.}}
+  } else if (rank == 1) {
+    MPI_Recv(&buf, 1, MPI_INT, rank - 1.1, 11, MPI_COMM_WORLD, MPI_STATUS_IGNORE); // expected-warning{{The type, argument at index 3 evaluates to, is not an integer type.}}
+  }
+}
+
+void invalidArgType2() {
+  int rank = 0;
+  int buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank == 0) {
+    MPI_Send(&buf, 1 + 1.1, MPI_INT, rank + 1, 12, MPI_COMM_WORLD); // expected-warning{{The type, argument at index 1 evaluates to, is not an integer type.}}
+  } else if (rank == 1) {
+    MPI_Recv(&buf, 1 + 1.1, MPI_INT, rank - 1, 12, MPI_COMM_WORLD, MPI_STATUS_IGNORE); // expected-warning{{The type, argument at index 1 evaluates to, is not an integer type.}}
+  }
+}
+
+void invalidArgType3() {
+  int rank = 0;
+  int buf = 0;
+  double x = 1.1;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank == 0) {
+    MPI_Send(&buf, 1 + x, MPI_INT, rank + 1, 13, MPI_COMM_WORLD); // expected-warning{{The type, argument at index 1 evaluates to, is not an integer type.}}
+  } else if (rank == 1) {
+    MPI_Recv(&buf, 1 + x, MPI_INT, rank - 1, 13, MPI_COMM_WORLD, MPI_STATUS_IGNORE); // expected-warning{{The type, argument at index 1 evaluates to, is not an integer type.}}
+  }
+}
+
+double d() { return 1.1; }
+void invalidArgType4() {
+  int rank = 0;
+  int buf = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank == 0) {
+    MPI_Send(&buf, 1, MPI_INT, rank + d(), 14, MPI_COMM_WORLD); // expected-warning{{The type, argument at index 3 evaluates to, is not an integer type.}}
+  } else if (rank == 1) {
+    MPI_Recv(&buf, 1, MPI_INT, rank - d(), 14, MPI_COMM_WORLD, MPI_STATUS_IGNORE); // expected-warning{{The type, argument at index 3 evaluates to, is not an integer type.}}
+  }
+}

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/unittests/StaticAnalyzer/CMakeLists.txt

   AnalyzerOptionsTest.cpp
   )
 
+add_subdirectory(MPI-Checker)
+
 target_link_libraries(StaticAnalysisTests
   clangBasic
   clangAnalysis
-  clangStaticAnalyzerCore 
+  clangStaticAnalyzerCore
   )

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/unittests/StaticAnalyzer/MPI-Checker/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS Support)
+
+include_directories(
+    ../../../lib/StaticAnalyzer/Checkers/MPI-Checker
+    )
+
+add_clang_unittest(MPI-Checker
+    ContainerTest.cpp
+    )
+
+target_link_libraries(MPI-Checker
+  clangAST
+  clangBasic
+  clangLex
+  clangParse
+  clangSema
+  clangStaticAnalyzerCheckers)

/Users/lx/Documents/Text/Code/Open_Source/llvm_trunk/repo/tools/clang/unittests/StaticAnalyzer/MPI-Checker/ContainerTest.cpp

+#include "gtest/gtest.h"
+#include <vector>
+#include "Container.h"
+
+TEST(Container, contains) {
+  std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 8, 9};
+  EXPECT_TRUE(cont::contains(v, 0));
+  EXPECT_TRUE(cont::contains(v, 3));
+  EXPECT_TRUE(cont::contains(v, 9));
+}