[clang] [clang][bytecode][NFC] Add a FunctionKind enum (PR #125391)
Timm Baeder via cfe-commits
cfe-commits at lists.llvm.org
Sun Feb 2 02:38:11 PST 2025
https://github.com/tbaederr updated https://github.com/llvm/llvm-project/pull/125391
>From df8e464c9d99d65f4c171c9de7000febd438d441 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timm=20B=C3=A4der?= <tbaeder at redhat.com>
Date: Sun, 2 Feb 2025 10:45:24 +0100
Subject: [PATCH] [clang][bytecode][NFC] Add a FunctionKind enum
Some function types are special to us, so add an enum and determinte the
function kind once when creating the function, instead of looking at the
Decl every time we need the information.
---
clang/lib/AST/ByteCode/ByteCodeEmitter.cpp | 11 ++---
clang/lib/AST/ByteCode/Function.cpp | 33 +++++++++------
clang/lib/AST/ByteCode/Function.h | 48 +++++++++++-----------
3 files changed, 48 insertions(+), 44 deletions(-)
diff --git a/clang/lib/AST/ByteCode/ByteCodeEmitter.cpp b/clang/lib/AST/ByteCode/ByteCodeEmitter.cpp
index 19e2416c4c9422c..5bd1b73133d6545 100644
--- a/clang/lib/AST/ByteCode/ByteCodeEmitter.cpp
+++ b/clang/lib/AST/ByteCode/ByteCodeEmitter.cpp
@@ -135,11 +135,9 @@ Function *ByteCodeEmitter::compileFunc(const FunctionDecl *FuncDecl) {
// Create a handle over the emitted code.
Function *Func = P.getFunction(FuncDecl);
if (!Func) {
- unsigned BuiltinID = FuncDecl->getBuiltinID();
- Func =
- P.createFunction(FuncDecl, ParamOffset, std::move(ParamTypes),
- std::move(ParamDescriptors), std::move(ParamOffsets),
- HasThisPointer, HasRVO, BuiltinID);
+ Func = P.createFunction(FuncDecl, ParamOffset, std::move(ParamTypes),
+ std::move(ParamDescriptors),
+ std::move(ParamOffsets), HasThisPointer, HasRVO);
}
assert(Func);
@@ -212,8 +210,7 @@ Function *ByteCodeEmitter::compileObjCBlock(const BlockExpr *BE) {
Function *Func =
P.createFunction(BE, ParamOffset, std::move(ParamTypes),
std::move(ParamDescriptors), std::move(ParamOffsets),
- /*HasThisPointer=*/false, /*HasRVO=*/false,
- /*IsUnevaluatedBuiltin=*/false);
+ /*HasThisPointer=*/false, /*HasRVO=*/false);
assert(Func);
Func->setDefined(true);
diff --git a/clang/lib/AST/ByteCode/Function.cpp b/clang/lib/AST/ByteCode/Function.cpp
index 896a4fb3f9469ae..6b892dfd616c177 100644
--- a/clang/lib/AST/ByteCode/Function.cpp
+++ b/clang/lib/AST/ByteCode/Function.cpp
@@ -19,12 +19,28 @@ Function::Function(Program &P, FunctionDeclTy Source, unsigned ArgSize,
llvm::SmallVectorImpl<PrimType> &&ParamTypes,
llvm::DenseMap<unsigned, ParamDescriptor> &&Params,
llvm::SmallVectorImpl<unsigned> &&ParamOffsets,
- bool HasThisPointer, bool HasRVO, unsigned BuiltinID)
- : P(P), Source(Source), ArgSize(ArgSize), ParamTypes(std::move(ParamTypes)),
- Params(std::move(Params)), ParamOffsets(std::move(ParamOffsets)),
- HasThisPointer(HasThisPointer), HasRVO(HasRVO), BuiltinID(BuiltinID) {
- if (const auto *F = Source.dyn_cast<const FunctionDecl *>())
+ bool HasThisPointer, bool HasRVO)
+ : P(P), Kind(FunctionKind::Normal), Source(Source), ArgSize(ArgSize),
+ ParamTypes(std::move(ParamTypes)), Params(std::move(Params)),
+ ParamOffsets(std::move(ParamOffsets)), HasThisPointer(HasThisPointer),
+ HasRVO(HasRVO) {
+ if (const auto *F = dyn_cast<const FunctionDecl *>(Source)) {
Variadic = F->isVariadic();
+ BuiltinID = F->getBuiltinID();
+ if (const auto *CD = dyn_cast<CXXConstructorDecl>(F)) {
+ Virtual = CD->isVirtual();
+ Kind = FunctionKind::Ctor;
+ } else if (const auto *CD = dyn_cast<CXXDestructorDecl>(F)) {
+ Virtual = CD->isVirtual();
+ Kind = FunctionKind::Dtor;
+ } else if (const auto *MD = dyn_cast<CXXMethodDecl>(F)) {
+ Virtual = MD->isVirtual();
+ if (MD->isLambdaStaticInvoker())
+ Kind = FunctionKind::LambdaStaticInvoker;
+ else if (clang::isLambdaCallOperator(F))
+ Kind = FunctionKind::LambdaCallOperator;
+ }
+ }
}
Function::ParamDescriptor Function::getParamDescriptor(unsigned Offset) const {
@@ -45,13 +61,6 @@ SourceInfo Function::getSource(CodePtr PC) const {
return It->second;
}
-bool Function::isVirtual() const {
- if (const auto *M = dyn_cast_if_present<CXXMethodDecl>(
- Source.dyn_cast<const FunctionDecl *>()))
- return M->isVirtual();
- return false;
-}
-
/// Unevaluated builtins don't get their arguments put on the stack
/// automatically. They instead operate on the AST of their Call
/// Expression.
diff --git a/clang/lib/AST/ByteCode/Function.h b/clang/lib/AST/ByteCode/Function.h
index 409a80f59f1e942..2d3421e5e612950 100644
--- a/clang/lib/AST/ByteCode/Function.h
+++ b/clang/lib/AST/ByteCode/Function.h
@@ -80,6 +80,13 @@ using FunctionDeclTy =
///
class Function final {
public:
+ enum class FunctionKind {
+ Normal,
+ Ctor,
+ Dtor,
+ LambdaStaticInvoker,
+ LambdaCallOperator,
+ };
using ParamDescriptor = std::pair<PrimType, Descriptor *>;
/// Returns the size of the function's local stack.
@@ -141,43 +148,31 @@ class Function final {
bool isConstexpr() const { return IsValid || isLambdaStaticInvoker(); }
/// Checks if the function is virtual.
- bool isVirtual() const;
+ bool isVirtual() const { return Virtual; };
/// Checks if the function is a constructor.
- bool isConstructor() const {
- return isa_and_nonnull<CXXConstructorDecl>(
- dyn_cast<const FunctionDecl *>(Source));
- }
+ bool isConstructor() const { return Kind == FunctionKind::Ctor; }
/// Checks if the function is a destructor.
- bool isDestructor() const {
- return isa_and_nonnull<CXXDestructorDecl>(
- dyn_cast<const FunctionDecl *>(Source));
- }
-
- /// Returns the parent record decl, if any.
- const CXXRecordDecl *getParentDecl() const {
- if (const auto *MD = dyn_cast_if_present<CXXMethodDecl>(
- dyn_cast<const FunctionDecl *>(Source)))
- return MD->getParent();
- return nullptr;
- }
+ bool isDestructor() const { return Kind == FunctionKind::Dtor; }
/// Returns whether this function is a lambda static invoker,
/// which we generate custom byte code for.
bool isLambdaStaticInvoker() const {
- if (const auto *MD = dyn_cast_if_present<CXXMethodDecl>(
- dyn_cast<const FunctionDecl *>(Source)))
- return MD->isLambdaStaticInvoker();
- return false;
+ return Kind == FunctionKind::LambdaStaticInvoker;
}
/// Returns whether this function is the call operator
/// of a lambda record decl.
bool isLambdaCallOperator() const {
+ return Kind == FunctionKind::LambdaCallOperator;
+ }
+
+ /// Returns the parent record decl, if any.
+ const CXXRecordDecl *getParentDecl() const {
if (const auto *MD = dyn_cast_if_present<CXXMethodDecl>(
dyn_cast<const FunctionDecl *>(Source)))
- return clang::isLambdaCallOperator(MD);
- return false;
+ return MD->getParent();
+ return nullptr;
}
/// Checks if the function is fully done compiling.
@@ -213,7 +208,7 @@ class Function final {
bool isThisPointerExplicit() const {
if (const auto *MD = dyn_cast_if_present<CXXMethodDecl>(
- Source.dyn_cast<const FunctionDecl *>()))
+ dyn_cast<const FunctionDecl *>(Source)))
return MD->isExplicitObjectMemberFunction();
return false;
}
@@ -232,7 +227,7 @@ class Function final {
llvm::SmallVectorImpl<PrimType> &&ParamTypes,
llvm::DenseMap<unsigned, ParamDescriptor> &&Params,
llvm::SmallVectorImpl<unsigned> &&ParamOffsets, bool HasThisPointer,
- bool HasRVO, unsigned BuiltinID);
+ bool HasRVO);
/// Sets the code of a function.
void setCode(unsigned NewFrameSize, std::vector<std::byte> &&NewCode,
@@ -255,6 +250,8 @@ class Function final {
/// Program reference.
Program &P;
+ /// Function Kind.
+ FunctionKind Kind;
/// Declaration this function was compiled from.
FunctionDeclTy Source;
/// Local area size: storage + metadata.
@@ -289,6 +286,7 @@ class Function final {
bool HasBody = false;
bool Defined = false;
bool Variadic = false;
+ bool Virtual = false;
unsigned BuiltinID = 0;
public:
More information about the cfe-commits
mailing list