コード例 #1
0
      void ConstCastAwayChecker::checkPreStmt(const clang::ExplicitCastExpr* CE, clang::ento::CheckerContext& C) const
      {
         const clang::Expr* E = CE->getSubExpr();
         clang::ASTContext& Ctx = C.getASTContext();
         clang::QualType OrigTy = Ctx.getCanonicalType(E->getType());
         clang::QualType ToTy = Ctx.getCanonicalType(CE->getType());

         if (support::isConst(OrigTy) && !support::isConst(ToTy)) {
            clang::ento::ExplodedNode* errorNode = C.addTransition();
            if (errorNode) {
               const char* msg = "[sas.ThreadSafety.ConstCastAwayChecker]const qualifier was removed via a cast, this may result in thread-unsafe code.";
               Report(CE, msg, C);
            }
         }
      }
コード例 #2
0
ファイル: PtrCastWinChecker.cpp プロジェクト: Barthelemy/SAS
 void PtrCastWinChecker::checkPreStmt(const clang::CStyleCastExpr* CE, clang::ento::CheckerContext& C) const
 {
    if (clang::CK_PointerToIntegral != CE->getCastKind()) return;
    auto subExpr = CE->getSubExpr();
    auto& Ctx = C.getASTContext();
    clang::QualType fromQType = Ctx.getCanonicalType(subExpr->getType());
    clang::QualType toQType = Ctx.getCanonicalType(CE->getType());
    if (fromQType->isPointerType() || fromQType->isArrayType()) {
       auto toType = toQType.getTypePtr();
       // Case one: the toType is a builtin and not a long long
       if (toType->isSpecificBuiltinType(clang::BuiltinType::Long) ||
           toType->isSpecificBuiltinType(clang::BuiltinType::ULong)){
           std::string r = "[sas.CodingConventions.ROOT.PtrCastWinChecker] Casting pointers to integer types which are not (unsigned) long long (in this case a ";
           r+=toQType.getAsString ();
           r+=") is wrong on Windows 64 bits. ";
           Report(CE, r.c_str(), C);
       }
    }
 }
コード例 #3
0
void ConstCastAwayChecker::checkPreStmt(const clang::ExplicitCastExpr *CE,
      clang::ento::CheckerContext &C) const 
{
   if (! ( clang::CStyleCastExpr::classof(CE) || clang::CXXConstCastExpr::classof(CE) ))
      return;
   const Expr * SE = CE->getSubExpr();   
   const CXXRecordDecl * CRD = nullptr;
   std::string cname;
   if (SE->getType()->isPointerType()) 
      CRD = SE->getType()->getPointeeCXXRecordDecl();
   else 
      CRD = SE->getType()->getAsCXXRecordDecl();

   if (CRD)
      cname = CRD->getQualifiedNameAsString();
   
   clang::ASTContext &Ctx = C.getASTContext();
   clang::QualType OrigTy = Ctx.getCanonicalType(SE->getType());
   clang::QualType ToTy = Ctx.getCanonicalType(CE->getType());

   if ( support::isConst( OrigTy ) && ! support::isConst(ToTy) ) {
      if ( clang::ento::ExplodedNode *errorNode = C.generateErrorNode()) {
         if (!BT)
            BT.reset(new clang::ento::BugType(this,"const cast away","ConstThreadSafety"));
         std::string buf;
         llvm::raw_string_ostream os(buf);
         os << "const qualifier was removed via a cast, this may result in thread-unsafe code.";  
         std::unique_ptr<clang::ento::BugReport> R = llvm::make_unique<clang::ento::BugReport>(*BT, 
               os.str(), errorNode);
         R->addRange(CE->getSourceRange());
         if ( ! m_exception.reportConstCastAway( *R, C ) )
             return;
         C.emitReport(std::move(R));
         if (cname == "")
             return;
         std::string tname ="constcastaway-checker.txt.unsorted";
         std::string tolog ="flagged class '"+cname+"' const qualifier cast away"; 
         support::writeLog(tolog,tname);
      }
   }
}
コード例 #4
0
void ConstCastAwayChecker::checkPreStmt(const clang::ExplicitCastExpr *CE,
		clang::ento::CheckerContext &C) const 
{
	const clang::Expr *E = CE->getSubExpr();
	clang::ASTContext &Ctx = C.getASTContext();
	clang::QualType OrigTy = Ctx.getCanonicalType(E->getType());
	clang::QualType ToTy = Ctx.getCanonicalType(CE->getType());

	if ( support::isConst( OrigTy ) && ! support::isConst(ToTy) ) {
		if ( clang::ento::ExplodedNode *errorNode = C.generateSink()) {
			if (!BT)
				BT.reset(
						new clang::ento::BugType("const cast away",
								"ThreadSafety"));
			clang::ento::BugReport *R = new clang::ento::BugReport(*BT, 
					"const qualifier was removed via a cast, this may result in thread-unsafe code.", errorNode);
			R->addRange(CE->getSourceRange());
		   	if ( ! m_exception.reportConstCastAway( *R, C ) )
				return;
			C.emitReport(R);
		}
	}
}
コード例 #5
0
ファイル: getParamDumper.cpp プロジェクト: Andrej-CMS/cmssw
void getParamDumper::analyzerEval(const clang::CallExpr *CE, clang::ento::CheckerContext &C) const {

  if ( ! C.getSourceManager().isInMainFile(CE->getExprLoc()) ) return;

  const FunctionDecl * FD = CE->getDirectCallee();

  if (!FD) return;

    std::string mname = support::getQualifiedName(*FD);
    const char *sfile=C.getSourceManager().getPresumedLoc(CE->getExprLoc()).getFilename();
    std::string sname(sfile);
    if ( ! support::isInterestingLocation(sname) ) return;
    std::string mdname;
    const FunctionDecl * MD = C.getCurrentAnalysisDeclContext()->getDecl()->getAsFunction();
    if (!MD) return;
    mdname = MD->getQualifiedNameAsString();
    for ( unsigned I=0, E=MD->getNumParams(); I != E; ++I) {
             std::string ps = "const class edm::ParameterSet ";
             std::string ups = "const class edm::UntrackedParameterSet ";
             std::string pname = MD->getParamDecl(I)->getQualifiedNameAsString();
             std::string qname = MD->getParamDecl(I)->getType().getCanonicalType().getAsString();
//             if (qname.substr(0,ps.length()) == ps || qname.substr(0,ups.length()) == ups) {
                  std::string buf;
                  llvm::raw_string_ostream os(buf);
                  os << "in function decl '"<< mdname << "' with parameter '"<< qname << " " << pname <<"'\n";
//                 }
         }
    const CXXMemberCallExpr * CXE = llvm::dyn_cast_or_null<CXXMemberCallExpr>(CE);
    if (!CXE) return;
    const Expr * IOA = CXE->getImplicitObjectArgument();
    std::string tname = "getparam-dumper.txt.unsorted";
    std::string gp = "edm::ParameterSet::getParameter";
    std::string gup = "edm::ParameterSet::getUntrackedParameter";
    if (mname.substr(0,gp.length()) == gp || mname.substr(0,gup.length()) == gup ) {
         std::string buf;
         llvm::raw_string_ostream os(buf);
         os << "in function decl '" << mdname << "' member function call '";
         clang::LangOptions LangOpts;
         LangOpts.CPlusPlus = true;
         clang::PrintingPolicy Policy(LangOpts);
         os << support::getQualifiedName(*(CXE->getMethodDecl()));
         os << "' with args '";
         for ( unsigned I=0, E=CE->getNumArgs(); I != E; ++I) {
              if (I) os <<", ";
              CE->getArg(I)->printPretty(os,0,Policy);
         }
         os << "' with implicit object '";
         const Expr * E = IOA->IgnoreParenNoopCasts(C.getASTContext());
         QualType QE = E->getType().getCanonicalType();
         os << QE.getAsString()<<" ";
         switch( E->getStmtClass() ) {
             case Stmt::MemberExprClass:
                 os << dyn_cast<MemberExpr>(E)->getMemberDecl()->getQualifiedNameAsString();
                 break;
             case Stmt::DeclRefExprClass:
                 os << dyn_cast<DeclRefExpr>(E)->getDecl()->getQualifiedNameAsString();
                 break;
             case Stmt::CXXOperatorCallExprClass:  
                 dyn_cast<CXXOperatorCallExpr>(E)->printPretty(os,0,Policy);
                 break;
             case Stmt::CXXBindTemporaryExprClass:
                 dyn_cast<CXXBindTemporaryExpr>(E)->printPretty(os,0,Policy);
                 break;
             case Stmt::CXXMemberCallExprClass:
                 dyn_cast<CXXMemberCallExpr>(E)->printPretty(os,0,Policy);
                 break;
             case Stmt::UnaryOperatorClass:
                 dyn_cast<UnaryOperator>(E)->printPretty(os,0,Policy);
                 break;
             default:
                 E->printPretty(os,0,Policy);
                 os << " unhandled expr class " <<E->getStmtClassName();
             }
         os<<"'\n";

         support::writeLog(os.str(),tname);
  }
  return ;
}