https://github.com/badumbatish updated https://github.com/llvm/llvm-project/pull/169081
>From d015af2cb7ca61a0445a78781b31178e3f6fa9f2 Mon Sep 17 00:00:00 2001 From: Jasmine Tang <[email protected]> Date: Thu, 20 Nov 2025 05:23:58 -0800 Subject: [PATCH 1/3] Skeleton --- .../include/clang/CIR/Sema/CIRAnalysisKind.h | 117 ++++++++++++ .../clang/CIR/Sema/FallThroughWarning.h | 66 +++++++ .../include/clang/Frontend/FrontendOptions.h | 3 + clang/include/clang/Options/Options.td | 5 + clang/lib/CIR/CMakeLists.txt | 1 + clang/lib/CIR/FrontendAction/CIRGenAction.cpp | 36 ++++ clang/lib/CIR/FrontendAction/CMakeLists.txt | 1 + clang/lib/CIR/Sema/CIRAnalysisKind.cpp | 67 +++++++ clang/lib/CIR/Sema/CMakeLists.txt | 19 ++ clang/lib/CIR/Sema/FallThroughWarning.cpp | 170 ++++++++++++++++++ 10 files changed, 485 insertions(+) create mode 100644 clang/include/clang/CIR/Sema/CIRAnalysisKind.h create mode 100644 clang/include/clang/CIR/Sema/FallThroughWarning.h create mode 100644 clang/lib/CIR/Sema/CIRAnalysisKind.cpp create mode 100644 clang/lib/CIR/Sema/CMakeLists.txt create mode 100644 clang/lib/CIR/Sema/FallThroughWarning.cpp diff --git a/clang/include/clang/CIR/Sema/CIRAnalysisKind.h b/clang/include/clang/CIR/Sema/CIRAnalysisKind.h new file mode 100644 index 0000000000000..304acfcf433db --- /dev/null +++ b/clang/include/clang/CIR/Sema/CIRAnalysisKind.h @@ -0,0 +1,117 @@ +//===--- CIRAnalysisKind.h - CIR Analysis Pass Kinds -----------*- 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 +/// Defines the CIR analysis pass kinds enum and related utilities. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_CIR_SEMA_CIRANALYSISKIND_H +#define LLVM_CLANG_CIR_SEMA_CIRANALYSISKIND_H + +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/raw_ostream.h" +#include <optional> +#include <string> +#include <vector> + +namespace cir { + +/// Enumeration of available CIR semantic analysis passes +enum class CIRAnalysisKind : unsigned { + Unrecognized = 0, + FallThrough = 1 << 0, // Fallthrough warning analysis + UnreachableCode = 1 << 1, // Unreachable code detection + NullCheck = 1 << 2, // Null pointer checks + UninitializedVar = 1 << 3, // Uninitialized variable detection + // Add more analysis passes here as needed +}; + +/// A set of CIR analysis passes (bitmask) +class CIRAnalysisSet { + unsigned mask = 0; + +public: + CIRAnalysisSet() = default; + explicit CIRAnalysisSet(CIRAnalysisKind kind) + : mask(static_cast<unsigned>(kind)) {} + explicit CIRAnalysisSet(unsigned mask) : mask(mask) {} + + /// Check if a specific analysis is enabled + bool has(CIRAnalysisKind kind) const { + return (mask & static_cast<unsigned>(kind)) != 0; + } + + /// Enable a specific analysis + void enable(CIRAnalysisKind kind) { + mask |= static_cast<unsigned>(kind); + } + + /// Disable a specific analysis + void disable(CIRAnalysisKind kind) { + mask &= ~static_cast<unsigned>(kind); + } + + /// Check if any analysis is enabled + bool hasAny() const { return mask != 0; } + + /// Check if no analysis is enabled + bool empty() const { return mask == 0; } + + /// Get the raw mask value + unsigned getMask() const { return mask; } + + /// Union with another set + CIRAnalysisSet &operator|=(const CIRAnalysisSet &other) { + mask |= other.mask; + return *this; + } + + /// Union operator + CIRAnalysisSet operator|(const CIRAnalysisSet &other) const { + return CIRAnalysisSet(mask | other.mask); + } + + /// Intersection with another set + CIRAnalysisSet &operator&=(const CIRAnalysisSet &other) { + mask &= other.mask; + return *this; + } + + /// Intersection operator + CIRAnalysisSet operator&(const CIRAnalysisSet &other) const { + return CIRAnalysisSet(mask & other.mask); + } + + bool operator==(const CIRAnalysisSet &other) const { + return mask == other.mask; + } + + bool operator!=(const CIRAnalysisSet &other) const { + return mask != other.mask; + } + + /// Print the analysis set to an output stream + void print(llvm::raw_ostream &OS) const; +}; + +/// Parse a single analysis name into a CIRAnalysisKind +/// Returns std::nullopt if the name is not recognized +CIRAnalysisKind parseCIRAnalysisKind(llvm::StringRef name); + +/// Parse a list of analysis names (from command line) into a CIRAnalysisSet +/// Handles comma and semicolon separators +/// Invalid names are ignored and optionally reported via InvalidNames +CIRAnalysisSet parseCIRAnalysisList( + const std::vector<std::string> &analysisList, + llvm::SmallVectorImpl<std::string> *invalidNames = nullptr); + +} // namespace cir + +#endif // LLVM_CLANG_CIR_SEMA_CIRANALYSISKIND_H diff --git a/clang/include/clang/CIR/Sema/FallThroughWarning.h b/clang/include/clang/CIR/Sema/FallThroughWarning.h new file mode 100644 index 0000000000000..808cf43f92ce0 --- /dev/null +++ b/clang/include/clang/CIR/Sema/FallThroughWarning.h @@ -0,0 +1,66 @@ +//===--- FallThroughWarning.h - CIR Fall-Through Analysis ------*- 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 +/// Defines the FallThroughWarningPass for CIR fall-through analysis. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_CIR_SEMA_FALLTHROUGHWARNING_H +#define LLVM_CLANG_CIR_SEMA_FALLTHROUGHWARNING_H + +#include "clang/AST/Type.h" +#include "clang/Basic/Diagnostic.h" +#include "clang/Basic/SourceLocation.h" +#include "clang/Sema/AnalysisBasedWarnings.h" + +#include "mlir/IR/Block.h" +#include "mlir/IR/Operation.h" +#include "mlir/Support/LLVM.h" +namespace cir { +class FuncOp; +} // namespace cir + +namespace clang { +class Sema; + +enum ControlFlowKind { + UnknownFallThrough, + NeverFallThrough, + MaybeFallThrough, + AlwaysFallThrough, + NeverFallThroughOrReturn +}; + +/// Configuration for fall-through diagnostics +struct CheckFallThroughDiagnostics { + unsigned diagFallThrough = 0; + unsigned diagReturn = 0; + unsigned diagFallThroughAttr = 0; + unsigned funKind = 0; + SourceLocation funcLoc; + + bool checkDiagnostics(DiagnosticsEngine &d, bool returnsVoid, + bool hasNoReturn) const; +}; + +/// Pass for analyzing fall-through behavior in CIR functions +class FallThroughWarningPass { +public: + FallThroughWarningPass() = default; + + /// Check fall-through behavior for a CIR function body + void checkFallThroughForFuncBody(Sema &s, cir::FuncOp cfg, QualType blockType, + const CheckFallThroughDiagnostics &cd); + ControlFlowKind checkFallThrough(cir::FuncOp cfg); + mlir::DenseSet<mlir::Block *> getLiveSet(cir::FuncOp cfg); +}; + +} // namespace clang + +#endif // LLVM_CLANG_CIR_SEMA_FALLTHROUGHWARNING_H diff --git a/clang/include/clang/Frontend/FrontendOptions.h b/clang/include/clang/Frontend/FrontendOptions.h index c919a53ae089e..a152309212bf8 100644 --- a/clang/include/clang/Frontend/FrontendOptions.h +++ b/clang/include/clang/Frontend/FrontendOptions.h @@ -420,6 +420,9 @@ class FrontendOptions { LLVM_PREFERRED_TYPE(bool) unsigned ClangIRDisableCIRVerifier : 1; + /// List of ClangIR semantic analysis passes to enable + std::vector<std::string> ClangIRAnalysisList; + CodeCompleteOptions CodeCompleteOpts; /// Specifies the output format of the AST. diff --git a/clang/include/clang/Options/Options.td b/clang/include/clang/Options/Options.td index 2f7434d8afe11..16821a7b6f230 100644 --- a/clang/include/clang/Options/Options.td +++ b/clang/include/clang/Options/Options.td @@ -3150,6 +3150,11 @@ def clangir_disable_verifier : Flag<["-"], "clangir-disable-verifier">, HelpText<"ClangIR: Disable MLIR module verifier">, MarshallingInfoFlag<FrontendOpts<"ClangIRDisableCIRVerifier">>; +def fclangir_analysis_EQ : CommaJoined<["-"], "fclangir-analysis=">, + Visibility<[ClangOption, CC1Option]>, + HelpText<"Enable ClangIR semantic analysis passes. Pass comma or semicolon separated list of analysis names">, + MarshallingInfoStringVector<FrontendOpts<"ClangIRAnalysisList">>; + defm clangir : BoolFOption<"clangir", FrontendOpts<"UseClangIRPipeline">, DefaultFalse, PosFlag<SetTrue, [], [ClangOption, CC1Option], "Use the ClangIR pipeline to compile">, diff --git a/clang/lib/CIR/CMakeLists.txt b/clang/lib/CIR/CMakeLists.txt index 7bdf3fcc59035..f86ad0933bce6 100644 --- a/clang/lib/CIR/CMakeLists.txt +++ b/clang/lib/CIR/CMakeLists.txt @@ -17,3 +17,4 @@ add_subdirectory(CodeGen) add_subdirectory(FrontendAction) add_subdirectory(Interfaces) add_subdirectory(Lowering) +add_subdirectory(Sema) diff --git a/clang/lib/CIR/FrontendAction/CIRGenAction.cpp b/clang/lib/CIR/FrontendAction/CIRGenAction.cpp index 67bb5657d4001..fb86b5f848628 100644 --- a/clang/lib/CIR/FrontendAction/CIRGenAction.cpp +++ b/clang/lib/CIR/FrontendAction/CIRGenAction.cpp @@ -10,12 +10,20 @@ #include "mlir/IR/MLIRContext.h" #include "mlir/IR/OwningOpRef.h" #include "clang/Basic/DiagnosticFrontend.h" +#include "clang/Basic/DiagnosticSema.h" #include "clang/CIR/CIRGenerator.h" #include "clang/CIR/CIRToCIRPasses.h" +#include "clang/CIR/Dialect/IR/CIRDialect.h" #include "clang/CIR/LowerToLLVM.h" +#include "clang/CIR/Sema/CIRAnalysisKind.h" +#include "clang/CIR/Sema/FallThroughWarning.h" #include "clang/CodeGen/BackendUtil.h" #include "clang/Frontend/CompilerInstance.h" +#include "clang/Sema/AnalysisBasedWarnings.h" +#include "clang/Sema/Sema.h" #include "llvm/IR/Module.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/raw_ostream.h" using namespace cir; using namespace clang; @@ -108,6 +116,34 @@ class CIRGenConsumer : public clang::ASTConsumer { mlir::ModuleOp MlirModule = Gen->getModule(); mlir::MLIRContext &MlirCtx = Gen->getMLIRContext(); + // Run CIR analysis passes if requested + if (!FEOptions.ClangIRAnalysisList.empty()) { + CIRAnalysisSet AnalysisSet = parseCIRAnalysisList(FEOptions.ClangIRAnalysisList); + AnalysisSet.print(llvm::errs()); + + if (AnalysisSet.has(CIRAnalysisKind::FallThrough)) { + // Get Sema for diagnostics + if (CI.hasSema()) { + Sema &S = CI.getSema(); + FallThroughWarningPass FallThroughPass; + + // Iterate over all functions in the CIR module + MlirModule.walk([&](cir::FuncOp FuncOp) { + // TODO: Get the proper QualType for the function + // For now, use an invalid QualType as placeholder + + QualType FuncType; + + // Set up diagnostics configuration + CheckFallThroughDiagnostics Diags; + + // Run fall-through analysis on this function + FallThroughPass.checkFallThroughForFuncBody(S, FuncOp, FuncType, Diags); + }); + } + } + } + if (!FEOptions.ClangIRDisablePasses) { // Setup and run CIR pipeline. if (runCIRToCIRPasses(MlirModule, MlirCtx, C, diff --git a/clang/lib/CIR/FrontendAction/CMakeLists.txt b/clang/lib/CIR/FrontendAction/CMakeLists.txt index 50d6ea7108ce1..f43ef2d8cbbf5 100644 --- a/clang/lib/CIR/FrontendAction/CMakeLists.txt +++ b/clang/lib/CIR/FrontendAction/CMakeLists.txt @@ -18,6 +18,7 @@ add_clang_library(clangCIRFrontendAction clangBasic clangFrontend clangCIR + clangCIRSema clangCIRLoweringCommon clangCIRLoweringDirectToLLVM clangCodeGen diff --git a/clang/lib/CIR/Sema/CIRAnalysisKind.cpp b/clang/lib/CIR/Sema/CIRAnalysisKind.cpp new file mode 100644 index 0000000000000..3ae24979cfe68 --- /dev/null +++ b/clang/lib/CIR/Sema/CIRAnalysisKind.cpp @@ -0,0 +1,67 @@ +//===--- CIRAnalysisKind.cpp - CIR Analysis Pass Kinds -------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +#include "clang/CIR/Sema/CIRAnalysisKind.h" +#include "llvm/ADT/StringSwitch.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/raw_ostream.h" +#include <optional> + +namespace cir { + +CIRAnalysisKind parseCIRAnalysisKind(llvm::StringRef name) { + auto parseResult = llvm::StringSwitch<CIRAnalysisKind>(name) + .Case("fallthrough", CIRAnalysisKind::FallThrough) + .Case("fall-through", CIRAnalysisKind::FallThrough) + .Default(CIRAnalysisKind::Unrecognized); + + return parseResult; +} + + +CIRAnalysisSet parseCIRAnalysisList( + const std::vector<std::string> &analysisList, + llvm::SmallVectorImpl<std::string> *invalidNames) { + CIRAnalysisSet result; + + for (const std::string &item : analysisList) { + llvm::StringRef remaining = item; + CIRAnalysisKind parseKind = parseCIRAnalysisKind(remaining); + if (parseKind == CIRAnalysisKind::Unrecognized) { + llvm::errs() << "Unrecognized CIR analysis option: " << remaining << "\n"; + continue; + } + result.enable(parseKind); + } + + return result; +} + +void CIRAnalysisSet::print(llvm::raw_ostream &OS) const { + if (empty()) { + OS << "none"; + return; + } + + bool first = true; + auto printIfEnabled = [&](CIRAnalysisKind kind, llvm::StringRef name) { + if (has(kind)) { + if (!first) + OS << ", "; + OS << name; + first = false; + } + }; + + printIfEnabled(CIRAnalysisKind::FallThrough, "fallthrough"); + printIfEnabled(CIRAnalysisKind::UnreachableCode, "unreachable-code"); + printIfEnabled(CIRAnalysisKind::NullCheck, "null-check"); + printIfEnabled(CIRAnalysisKind::UninitializedVar, "uninitialized-var"); +} + +} // namespace cir diff --git a/clang/lib/CIR/Sema/CMakeLists.txt b/clang/lib/CIR/Sema/CMakeLists.txt new file mode 100644 index 0000000000000..acf49742d8e4c --- /dev/null +++ b/clang/lib/CIR/Sema/CMakeLists.txt @@ -0,0 +1,19 @@ +add_clang_library(clangCIRSema + FallThroughWarning.cpp + CIRAnalysisKind.cpp + + DEPENDS + MLIRCIRPassIncGen + + LINK_LIBS PUBLIC + clangAST + clangBasic + + MLIRAnalysis + MLIRIR + MLIRPass + MLIRTransformUtils + + MLIRCIR + MLIRCIRInterfaces +) diff --git a/clang/lib/CIR/Sema/FallThroughWarning.cpp b/clang/lib/CIR/Sema/FallThroughWarning.cpp new file mode 100644 index 0000000000000..5fdc9ffc083cb --- /dev/null +++ b/clang/lib/CIR/Sema/FallThroughWarning.cpp @@ -0,0 +1,170 @@ +#include "clang/CIR/Sema/FallThroughWarning.h" +#include "clang/AST/ASTContext.h" +#include "clang/Basic/DiagnosticSema.h" +#include "clang/Basic/SourceLocation.h" +#include "clang/Basic/TargetInfo.h" +#include "clang/CIR/Dialect/IR/CIRDialect.h" +#include "clang/CIR/Dialect/IR/CIRTypes.h" +#include "clang/Sema/Sema.h" +#include "llvm/Support/raw_ostream.h" + +using namespace mlir; +using namespace cir; +using namespace clang; + +namespace clang { + +//===----------------------------------------------------------------------===// +// Check for missing return value. +//===----------------------------------------------------------------------===// + +bool CheckFallThroughDiagnostics::checkDiagnostics(DiagnosticsEngine &d, + bool returnsVoid, + bool hasNoReturn) const { + if (funKind == diag::FalloffFunctionKind::Function) { + return (returnsVoid || d.isIgnored(diag::warn_falloff_nonvoid, funcLoc)) && + (!hasNoReturn || + d.isIgnored(diag::warn_noreturn_has_return_expr, funcLoc)) && + (!returnsVoid || + d.isIgnored(diag::warn_suggest_noreturn_block, funcLoc)); + } + if (funKind == diag::FalloffFunctionKind::Coroutine) { + return (returnsVoid || d.isIgnored(diag::warn_falloff_nonvoid, funcLoc)) && + (!hasNoReturn); + } + // For blocks / lambdas. + return returnsVoid && !hasNoReturn; +} + +// TODO: Add a class for fall through config later + +void FallThroughWarningPass::checkFallThroughForFuncBody( + Sema &s, cir::FuncOp cfg, QualType blockType, + const CheckFallThroughDiagnostics &cd) { + + llvm::errs() << "Hello world, you're in CIR sema analysis\n"; + bool returnsVoid = false; + bool hasNoReturn = false; + + // Supposedly all function in cir is FuncOp + // 1. If normal function (FunctionDecl), check if it's coroutine. + // 1a. if coroutine -> check the fallthrough handler (idk what this means, + // TODO for now) + if (cfg.getCoroutine()) { + // TODO: Let's not worry about coroutine for now + } else + returnsVoid = isa<cir::VoidType>(cfg.getFunctionType().getReturnType()); + + // TODO: Do we need to check for InferredNoReturnAttr just like in OG? + hasNoReturn = cfg.getFunctionType().getReturnTypes().empty(); + + DiagnosticsEngine &diags = s.getDiagnostics(); + if (cd.checkDiagnostics(diags, returnsVoid, hasNoReturn)) { + return; + } + + // cpu_dispatch functions permit empty function bodies for ICC compatibility. + // TODO: Do we have isCPUDispatchMultiVersion? + checkFallThrough(cfg); +} + +mlir::DenseSet<mlir::Block *> +FallThroughWarningPass::getLiveSet(cir::FuncOp cfg) { + mlir::DenseSet<mlir::Block *> liveSet; + if (cfg.getBody().empty()) + return liveSet; + + auto &first = cfg.getBody().getBlocks().front(); + + for (auto &block : cfg.getBody()) { + if (block.isReachable(&first)) + liveSet.insert(&block); + } + return liveSet; +} + +ControlFlowKind FallThroughWarningPass::checkFallThrough(cir::FuncOp cfg) { + + assert(cfg && "there can't be a null func op"); + + // TODO: Is no CFG akin to a declaration? + if (cfg.isDeclaration()) { + return UnknownFallThrough; + } + + mlir::DenseSet<mlir::Block *> liveSet = this->getLiveSet(cfg); + + unsigned count = liveSet.size(); + + bool hasLiveReturn = false; + bool hasFakeEdge = false; + bool hasPlainEdge = false; + bool hasAbnormalEdge = false; + + auto &exitBlock = cfg.getBody().back(); + // INFO: in OG clang CFG, they have an empty exit block, so when they query + // pred of exit OG, they get all exit blocks + // + // I guess in CIR, we can pretend exit blocks are all blocks that have no + // successor? + for (mlir::Block &pred : cfg.getBody().getBlocks()) { + if (!liveSet.contains(&pred)) + continue; + + // We consider no predecessors as 'exit blocks' + if (!pred.hasNoSuccessors()) + continue; + + if (!pred.mightHaveTerminator()) + continue; + + mlir::Operation *term = pred.getTerminator(); + if (isa<cir::ReturnOp>(term)) { + hasAbnormalEdge = true; + continue; + } + + // INFO: In OG, we'll be looking for destructor since it can appear past + // return but i guess not in CIR? In this case we'll only be examining the + // terminator + + if (isa<cir::TryOp>(term)) { + hasAbnormalEdge = true; + continue; + } + + // INFO: OG clang has this equals true whenever ri == re, which means this + // is true only when a block only has the terminator, or its size is 1. + hasPlainEdge = std::distance(pred.begin(), pred.end()) == 1; + + if (isa<cir::ReturnOp>(term)) { + hasLiveReturn = true; + continue; + } + if (isa<cir::TryOp>(term)) { + hasLiveReturn = true; + continue; + } + + // TODO: Maybe one day throw will be terminator? + // + // TODO: We need to add a microsoft inline assembly enum + + // TODO: We don't concer with try op either since it's not terminator + + hasPlainEdge = true; + } + + if (!hasPlainEdge) { + if (hasLiveReturn) + return NeverFallThrough; + return NeverFallThroughOrReturn; + } + if (hasAbnormalEdge || hasFakeEdge || hasLiveReturn) + return MaybeFallThrough; + // This says AlwaysFallThrough for calls to functions that are not marked + // noreturn, that don't return. If people would like this warning to be more + // accurate, such functions should be marked as noreturn. + return AlwaysFallThrough; +} +} // namespace clang >From 0eafeed1b29169fa5b8100084da13086855ca263 Mon Sep 17 00:00:00 2001 From: Jasmine Tang <[email protected]> Date: Thu, 20 Nov 2025 19:05:04 -0800 Subject: [PATCH 2/3] Fix reachable behaviors --- clang/lib/CIR/Sema/FallThroughWarning.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clang/lib/CIR/Sema/FallThroughWarning.cpp b/clang/lib/CIR/Sema/FallThroughWarning.cpp index 5fdc9ffc083cb..dd22317fb48ba 100644 --- a/clang/lib/CIR/Sema/FallThroughWarning.cpp +++ b/clang/lib/CIR/Sema/FallThroughWarning.cpp @@ -77,7 +77,7 @@ FallThroughWarningPass::getLiveSet(cir::FuncOp cfg) { auto &first = cfg.getBody().getBlocks().front(); for (auto &block : cfg.getBody()) { - if (block.isReachable(&first)) + if (first.isReachable(&block)) liveSet.insert(&block); } return liveSet; >From 0e416f49e38bfef8b7a4520424e1495e17b78f86 Mon Sep 17 00:00:00 2001 From: Jasmine Tang <[email protected]> Date: Sun, 23 Nov 2025 01:33:00 -0800 Subject: [PATCH 3/3] Rename sema/ to analysis/ and add new test --- .../CIR/{Sema => Analysis}/CIRAnalysisKind.h | 0 .../{Sema => Analysis}/FallThroughWarning.h | 6 +- .../{Sema => Analysis}/CIRAnalysisKind.cpp | 2 +- .../lib/CIR/{Sema => Analysis}/CMakeLists.txt | 0 .../{Sema => Analysis}/FallThroughWarning.cpp | 58 ++++++++++++++++++- clang/lib/CIR/CMakeLists.txt | 2 +- clang/lib/CIR/FrontendAction/CIRGenAction.cpp | 4 +- clang/test/CIR/Analysis/fallthrough_1.c | 33 +++++++++++ clang/test/CIR/Analysis/fallthrough_2.c | 37 ++++++++++++ 9 files changed, 132 insertions(+), 10 deletions(-) rename clang/include/clang/CIR/{Sema => Analysis}/CIRAnalysisKind.h (100%) rename clang/include/clang/CIR/{Sema => Analysis}/FallThroughWarning.h (93%) rename clang/lib/CIR/{Sema => Analysis}/CIRAnalysisKind.cpp (97%) rename clang/lib/CIR/{Sema => Analysis}/CMakeLists.txt (100%) rename clang/lib/CIR/{Sema => Analysis}/FallThroughWarning.cpp (74%) create mode 100644 clang/test/CIR/Analysis/fallthrough_1.c create mode 100644 clang/test/CIR/Analysis/fallthrough_2.c diff --git a/clang/include/clang/CIR/Sema/CIRAnalysisKind.h b/clang/include/clang/CIR/Analysis/CIRAnalysisKind.h similarity index 100% rename from clang/include/clang/CIR/Sema/CIRAnalysisKind.h rename to clang/include/clang/CIR/Analysis/CIRAnalysisKind.h diff --git a/clang/include/clang/CIR/Sema/FallThroughWarning.h b/clang/include/clang/CIR/Analysis/FallThroughWarning.h similarity index 93% rename from clang/include/clang/CIR/Sema/FallThroughWarning.h rename to clang/include/clang/CIR/Analysis/FallThroughWarning.h index 808cf43f92ce0..3f87b3f867d65 100644 --- a/clang/include/clang/CIR/Sema/FallThroughWarning.h +++ b/clang/include/clang/CIR/Analysis/FallThroughWarning.h @@ -39,9 +39,9 @@ enum ControlFlowKind { /// Configuration for fall-through diagnostics struct CheckFallThroughDiagnostics { - unsigned diagFallThrough = 0; - unsigned diagReturn = 0; - unsigned diagFallThroughAttr = 0; + unsigned diagFallThroughHasNoReturn = 0; + unsigned diagFallThroughReturnsNonVoid = 0; + unsigned diagNeverFallThroughOrReturn = 0; unsigned funKind = 0; SourceLocation funcLoc; diff --git a/clang/lib/CIR/Sema/CIRAnalysisKind.cpp b/clang/lib/CIR/Analysis/CIRAnalysisKind.cpp similarity index 97% rename from clang/lib/CIR/Sema/CIRAnalysisKind.cpp rename to clang/lib/CIR/Analysis/CIRAnalysisKind.cpp index 3ae24979cfe68..f27f8dbeb731d 100644 --- a/clang/lib/CIR/Sema/CIRAnalysisKind.cpp +++ b/clang/lib/CIR/Analysis/CIRAnalysisKind.cpp @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// -#include "clang/CIR/Sema/CIRAnalysisKind.h" +#include "clang/CIR/Analysis/CIRAnalysisKind.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/raw_ostream.h" diff --git a/clang/lib/CIR/Sema/CMakeLists.txt b/clang/lib/CIR/Analysis/CMakeLists.txt similarity index 100% rename from clang/lib/CIR/Sema/CMakeLists.txt rename to clang/lib/CIR/Analysis/CMakeLists.txt diff --git a/clang/lib/CIR/Sema/FallThroughWarning.cpp b/clang/lib/CIR/Analysis/FallThroughWarning.cpp similarity index 74% rename from clang/lib/CIR/Sema/FallThroughWarning.cpp rename to clang/lib/CIR/Analysis/FallThroughWarning.cpp index dd22317fb48ba..d437eb6c377c4 100644 --- a/clang/lib/CIR/Sema/FallThroughWarning.cpp +++ b/clang/lib/CIR/Analysis/FallThroughWarning.cpp @@ -1,4 +1,4 @@ -#include "clang/CIR/Sema/FallThroughWarning.h" +#include "clang/CIR/Analysis/FallThroughWarning.h" #include "clang/AST/ASTContext.h" #include "clang/Basic/DiagnosticSema.h" #include "clang/Basic/SourceLocation.h" @@ -6,6 +6,7 @@ #include "clang/CIR/Dialect/IR/CIRDialect.h" #include "clang/CIR/Dialect/IR/CIRTypes.h" #include "clang/Sema/Sema.h" +#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/raw_ostream.h" using namespace mlir; @@ -14,6 +15,36 @@ using namespace clang; namespace clang { +//===----------------------------------------------------------------------===// +// Helper function to lookup a Decl by name from ASTContext +//===----------------------------------------------------------------------===// + +/// Lookup a declaration by name in the translation unit. +/// \param Context The ASTContext to search in +/// \param Name The name of the declaration to find +/// \return The found Decl, or nullptr if not found + +/// WARN: I have to say, we only use this because a lot of the time, attribute +/// that we might need are not port to CIR currently so this function is +/// basically a crutch for that +static Decl *getDeclByName(ASTContext &context, StringRef name) { + // Get the identifier for the name + IdentifierInfo *ii = &context.Idents.get(name); + + // Create a DeclarationName from the identifier + DeclarationName dName(ii); + + // Lookup in the translation unit + TranslationUnitDecl *tu = context.getTranslationUnitDecl(); + DeclContext::lookup_result result = tu->lookup(dName); + + // Return the first match, or nullptr if not found + if (result.empty()) + return nullptr; + + return result.front(); +} + //===----------------------------------------------------------------------===// // Check for missing return value. //===----------------------------------------------------------------------===// @@ -41,8 +72,11 @@ bool CheckFallThroughDiagnostics::checkDiagnostics(DiagnosticsEngine &d, void FallThroughWarningPass::checkFallThroughForFuncBody( Sema &s, cir::FuncOp cfg, QualType blockType, const CheckFallThroughDiagnostics &cd) { - llvm::errs() << "Hello world, you're in CIR sema analysis\n"; + + auto *d = getDeclByName(s.getASTContext(), cfg.getName()); + assert(d && "we need non null decl"); + bool returnsVoid = false; bool hasNoReturn = false; @@ -65,7 +99,25 @@ void FallThroughWarningPass::checkFallThroughForFuncBody( // cpu_dispatch functions permit empty function bodies for ICC compatibility. // TODO: Do we have isCPUDispatchMultiVersion? - checkFallThrough(cfg); + + switch (ControlFlowKind fallThroughType = checkFallThrough(cfg)) { + case UnknownFallThrough: + case MaybeFallThrough: + case AlwaysFallThrough: + if (hasNoReturn && cd.diagFallThroughHasNoReturn) { + + } else if (!returnsVoid && cd.diagFallThroughReturnsNonVoid) { + + } + break; + case NeverFallThroughOrReturn: + if (returnsVoid && !hasNoReturn && cd.diagNeverFallThroughOrReturn) { + } + break; + + case NeverFallThrough: { + } break; + } } mlir::DenseSet<mlir::Block *> diff --git a/clang/lib/CIR/CMakeLists.txt b/clang/lib/CIR/CMakeLists.txt index f86ad0933bce6..c698267b04ef5 100644 --- a/clang/lib/CIR/CMakeLists.txt +++ b/clang/lib/CIR/CMakeLists.txt @@ -17,4 +17,4 @@ add_subdirectory(CodeGen) add_subdirectory(FrontendAction) add_subdirectory(Interfaces) add_subdirectory(Lowering) -add_subdirectory(Sema) +add_subdirectory(Analysis) diff --git a/clang/lib/CIR/FrontendAction/CIRGenAction.cpp b/clang/lib/CIR/FrontendAction/CIRGenAction.cpp index fb86b5f848628..bcb8e8fbb644d 100644 --- a/clang/lib/CIR/FrontendAction/CIRGenAction.cpp +++ b/clang/lib/CIR/FrontendAction/CIRGenAction.cpp @@ -15,8 +15,8 @@ #include "clang/CIR/CIRToCIRPasses.h" #include "clang/CIR/Dialect/IR/CIRDialect.h" #include "clang/CIR/LowerToLLVM.h" -#include "clang/CIR/Sema/CIRAnalysisKind.h" -#include "clang/CIR/Sema/FallThroughWarning.h" +#include "clang/CIR/Analysis/CIRAnalysisKind.h" +#include "clang/CIR/Analysis/FallThroughWarning.h" #include "clang/CodeGen/BackendUtil.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Sema/AnalysisBasedWarnings.h" diff --git a/clang/test/CIR/Analysis/fallthrough_1.c b/clang/test/CIR/Analysis/fallthrough_1.c new file mode 100644 index 0000000000000..267745afeba5d --- /dev/null +++ b/clang/test/CIR/Analysis/fallthrough_1.c @@ -0,0 +1,33 @@ +// REQUIRES: false + +// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -fclangir-analysis="fallthrough" -w +// INFO: These test cases are derived from clang/test/Sema/return.c +int unknown(void); + +int test7(void) { + unknown(); +} // expected-warning {{non-void function does not return a value}} + +int test8(void) { + (void)(1 + unknown()); +} // expected-warning {{non-void function does not return a value}} + + + +int test14(void) { + (void)(1 || unknown()); +} // expected-warning {{non-void function does not return a value}} + +int test15(void) { + (void)(0 || unknown()); +} // expected-warning {{non-void function does not return a value}} + +int test16(void) { + (void)(0 && unknown()); +} // expected-warning {{non-void function does not return a value}} + +int test17(void) { + (void)(1 && unknown()); +} // expected-warning {{non-void function does not return a value}} + + diff --git a/clang/test/CIR/Analysis/fallthrough_2.c b/clang/test/CIR/Analysis/fallthrough_2.c new file mode 100644 index 0000000000000..22c399730a4ff --- /dev/null +++ b/clang/test/CIR/Analysis/fallthrough_2.c @@ -0,0 +1,37 @@ +// REQUIRES: false + +// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -fclangir-analysis="fallthrough" -w +// INFO: These test cases are derived from clang/test/Sema/return.c + +int test1(void) { +} // expected-warning {{non-void function does not return a value}} + +int test3(void) { + goto a; + a: ; +} // expected-warning {{non-void function does not return a value}} + +int test20(void) { + int i; + if (i) + return 0; + else if (0) + return 2; +} // expected-warning {{non-void function does not return a value in all control paths}} + +int test22(void) { + int i; + switch (i) default: ; +} // expected-warning {{non-void function does not return a value}} + +int test23(void) { + int i; + switch (i) { + case 0: + return 0; + case 2: + return 2; + } +} // expected-warning {{non-void function does not return a value in all control paths}} + + _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
