//===-- MPIFunctionClassifier.cpp - classifies MPI functions ----*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

///

/// \file

/// This file defines functionality to identify and classify MPI functions.

///

//===----------------------------------------------------------------------===//

#include "clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h"

#include "llvm/ADT/STLExtras.h"

namespace clang {

namespace ento {

namespace mpi {

void MPIFunctionClassifier::identifierInit(ASTContext &ASTCtx) {

  // Initialize function identifiers.

  initPointToPointIdentifiers(ASTCtx);

  initCollectiveIdentifiers(ASTCtx);

  initAdditionalIdentifiers(ASTCtx);

}

void MPIFunctionClassifier::initPointToPointIdentifiers(ASTContext &ASTCtx) {

  // Copy identifiers into the correct classification containers.

  IdentInfo_MPI_Send = &ASTCtx.Idents.get("MPI_Send");

  MPIPointToPointTypes.push_back(IdentInfo_MPI_Send);

  MPIType.push_back(IdentInfo_MPI_Send);

  assert(IdentInfo_MPI_Send);

  IdentInfo_MPI_Isend = &ASTCtx.Idents.get("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");

  MPIPointToPointTypes.push_back(IdentInfo_MPI_Ssend);

  MPIType.push_back(IdentInfo_MPI_Ssend);

  assert(IdentInfo_MPI_Ssend);

  IdentInfo_MPI_Issend = &ASTCtx.Idents.get("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");

  MPIPointToPointTypes.push_back(IdentInfo_MPI_Bsend);

  MPIType.push_back(IdentInfo_MPI_Bsend);

  assert(IdentInfo_MPI_Bsend);

  IdentInfo_MPI_Ibsend = &ASTCtx.Idents.get("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");

  MPIPointToPointTypes.push_back(IdentInfo_MPI_Rsend);

  MPIType.push_back(IdentInfo_MPI_Rsend);

  assert(IdentInfo_MPI_Rsend);

  IdentInfo_MPI_Irsend = &ASTCtx.Idents.get("MPI_Irsend");

  MPIPointToPointTypes.push_back(IdentInfo_MPI_Irsend);

  MPIType.push_back(IdentInfo_MPI_Irsend);

  assert(IdentInfo_MPI_Irsend);

  IdentInfo_MPI_Recv = &ASTCtx.Idents.get("MPI_Recv");

  MPIPointToPointTypes.push_back(IdentInfo_MPI_Recv);

  MPIType.push_back(IdentInfo_MPI_Recv);

  assert(IdentInfo_MPI_Recv);

  IdentInfo_MPI_Irecv = &ASTCtx.Idents.get("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(ASTContext &ASTCtx) {

  // 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);

  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);

  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);

  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);

  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);

  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);

  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);

  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(ASTContext &ASTCtx) {

  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_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 llvm::is_contained(MPIType, IdentInfo);

}

bool MPIFunctionClassifier::isNonBlockingType(

    const IdentifierInfo *IdentInfo) const {

  return llvm::is_contained(MPINonBlockingTypes, IdentInfo);

}

// point-to-point identifiers

bool MPIFunctionClassifier::isPointToPointType(

    const IdentifierInfo *IdentInfo) const {

  return llvm::is_contained(MPIPointToPointTypes, IdentInfo);

}

// collective identifiers

bool MPIFunctionClassifier::isCollectiveType(

    const IdentifierInfo *IdentInfo) const {

  return llvm::is_contained(MPICollectiveTypes, IdentInfo);

}

bool MPIFunctionClassifier::isCollToColl(

    const IdentifierInfo *IdentInfo) const {

  return llvm::is_contained(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_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::isWaitType(const IdentifierInfo *IdentInfo) const {

  return IdentInfo == IdentInfo_MPI_Wait || 
IdentInfo == IdentInfo_MPI_Waitall92
;

}

} // end of namespace: mpi

} // end of namespace: ento

} // end of namespace: clang