Skip to content

Commit 3f6ef4e

Browse files
el-evel-ev
authored
[CIR] Cleanup support for C functions (llvm#136854)
This adds basic handling for non-prototype functions in C. Closes llvm#130200.
1 parent e7547b2 commit 3f6ef4e

File tree

7 files changed

+202
-53
lines changed

7 files changed

+202
-53
lines changed

‎clang/lib/CIR/CodeGen/CIRGenCall.cpp‎

Lines changed: 46 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -13,32 +13,51 @@
1313

1414
#include "CIRGenCall.h"
1515
#include "CIRGenFunction.h"
16+
#include "CIRGenFunctionInfo.h"
1617
#include "clang/CIR/MissingFeatures.h"
1718

1819
using namespace clang;
1920
using namespace clang::CIRGen;
2021

2122
CIRGenFunctionInfo *
2223
CIRGenFunctionInfo::create(CanQualType resultType,
23-
llvm::ArrayRef<CanQualType> argTypes) {
24+
llvm::ArrayRef<CanQualType> argTypes,
25+
RequiredArgs required) {
2426
// The first slot allocated for ArgInfo is for the return value.
2527
void *buffer = operator new(totalSizeToAlloc<ArgInfo>(argTypes.size() + 1));
2628

29+
assert(!cir::MissingFeatures::opCallCIRGenFuncInfoParamInfo());
30+
2731
CIRGenFunctionInfo *fi = new (buffer) CIRGenFunctionInfo();
28-
fi->numArgs = argTypes.size();
2932

30-
assert(!cir::MissingFeatures::opCallCIRGenFuncInfoParamInfo());
33+
fi->required = required;
34+
fi->numArgs = argTypes.size();
3135

3236
ArgInfo *argsBuffer = fi->getArgsBuffer();
3337
(argsBuffer++)->type = resultType;
3438
for (CanQualType ty : argTypes)
3539
(argsBuffer++)->type = ty;
36-
3740
assert(!cir::MissingFeatures::opCallCIRGenFuncInfoExtParamInfo());
3841

3942
return fi;
4043
}
4144

45+
cir::FuncType CIRGenTypes::getFunctionType(const CIRGenFunctionInfo &fi) {
46+
mlir::Type resultType = convertType(fi.getReturnType());
47+
48+
SmallVector<mlir::Type, 8> argTypes(fi.getNumRequiredArgs());
49+
50+
unsigned argNo = 0;
51+
llvm::ArrayRef<CIRGenFunctionInfoArgInfo> argInfos(fi.argInfoBegin(),
52+
fi.getNumRequiredArgs());
53+
for (const auto &argInfo : argInfos)
54+
argTypes[argNo++] = convertType(argInfo.type);
55+
56+
return cir::FuncType::get(argTypes,
57+
(resultType ? resultType : builder.getVoidTy()),
58+
fi.isVariadic());
59+
}
60+
4261
CIRGenCallee CIRGenCallee::prepareConcreteCallee(CIRGenFunction &cgf) const {
4362
assert(!cir::MissingFeatures::opCallVirtual());
4463
return *this;
@@ -48,6 +67,9 @@ static const CIRGenFunctionInfo &
4867
arrangeFreeFunctionLikeCall(CIRGenTypes &cgt, CIRGenModule &cgm,
4968
const CallArgList &args,
5069
const FunctionType *fnType) {
70+
71+
RequiredArgs required = RequiredArgs::All;
72+
5173
if (const auto *proto = dyn_cast<FunctionProtoType>(fnType)) {
5274
if (proto->isVariadic())
5375
cgm.errorNYI("call to variadic function");
@@ -64,7 +86,7 @@ arrangeFreeFunctionLikeCall(CIRGenTypes &cgt, CIRGenModule &cgm,
6486
CanQualType retType = fnType->getReturnType()
6587
->getCanonicalTypeUnqualified()
6688
.getUnqualifiedType();
67-
return cgt.arrangeCIRFunctionInfo(retType, argTypes);
89+
return cgt.arrangeCIRFunctionInfo(retType, argTypes, required);
6890
}
6991

7092
const CIRGenFunctionInfo &
@@ -88,6 +110,23 @@ emitCallLikeOp(CIRGenFunction &cgf, mlir::Location callLoc,
88110
return builder.createCallOp(callLoc, directFuncOp, cirCallArgs);
89111
}
90112

113+
const CIRGenFunctionInfo &
114+
CIRGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> fpt) {
115+
SmallVector<CanQualType, 8> argTypes;
116+
for (unsigned i = 0, e = fpt->getNumParams(); i != e; ++i)
117+
argTypes.push_back(fpt->getParamType(i));
118+
RequiredArgs required = RequiredArgs::forPrototypePlus(fpt);
119+
120+
CanQualType resultType = fpt->getReturnType().getUnqualifiedType();
121+
return arrangeCIRFunctionInfo(resultType, argTypes, required);
122+
}
123+
124+
const CIRGenFunctionInfo &
125+
CIRGenTypes::arrangeFreeFunctionType(CanQual<FunctionNoProtoType> fnpt) {
126+
CanQualType resultType = fnpt->getReturnType().getUnqualifiedType();
127+
return arrangeCIRFunctionInfo(resultType, {}, RequiredArgs(0));
128+
}
129+
91130
RValue CIRGenFunction::emitCall(const CIRGenFunctionInfo &funcInfo,
92131
const CIRGenCallee &callee,
93132
ReturnValueSlot returnValue,
@@ -102,7 +141,8 @@ RValue CIRGenFunction::emitCall(const CIRGenFunctionInfo &funcInfo,
102141

103142
// Translate all of the arguments as necessary to match the CIR lowering.
104143
for (auto [argNo, arg, argInfo] :
105-
llvm::enumerate(args, funcInfo.arguments())) {
144+
llvm::enumerate(args, funcInfo.argInfos())) {
145+
106146
// Insert a padding argument to ensure proper alignment.
107147
assert(!cir::MissingFeatures::opCallPaddingArgs());
108148

‎clang/lib/CIR/CodeGen/CIRGenFunctionInfo.h‎

Lines changed: 80 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -25,20 +25,68 @@ struct CIRGenFunctionInfoArgInfo {
2525
CanQualType type;
2626
};
2727

28+
/// A class for recording the number of arguments that a function signature
29+
/// requires.
30+
class RequiredArgs {
31+
/// The number of required arguments, or ~0 if the signature does not permit
32+
/// optional arguments.
33+
unsigned numRequired;
34+
35+
public:
36+
enum All_t { All };
37+
38+
RequiredArgs(All_t _) : numRequired(~0U) {}
39+
explicit RequiredArgs(unsigned n) : numRequired(n) { assert(n != ~0U); }
40+
41+
unsigned getOpaqueData() const { return numRequired; }
42+
43+
bool allowsOptionalArgs() const { return numRequired != ~0U; }
44+
45+
/// Compute the arguments required by the given formal prototype, given that
46+
/// there may be some additional, non-formal arguments in play.
47+
///
48+
/// If FD is not null, this will consider pass_object_size params in FD.
49+
static RequiredArgs
50+
forPrototypePlus(const clang::FunctionProtoType *prototype) {
51+
if (!prototype->isVariadic())
52+
return All;
53+
54+
if (prototype->hasExtParameterInfos())
55+
llvm_unreachable("NYI");
56+
57+
return RequiredArgs(prototype->getNumParams());
58+
}
59+
60+
static RequiredArgs
61+
forPrototypePlus(clang::CanQual<clang::FunctionProtoType> prototype) {
62+
return forPrototypePlus(prototype.getTypePtr());
63+
}
64+
65+
unsigned getNumRequiredArgs() const {
66+
assert(allowsOptionalArgs());
67+
return numRequired;
68+
}
69+
};
70+
2871
class CIRGenFunctionInfo final
2972
: public llvm::FoldingSetNode,
3073
private llvm::TrailingObjects<CIRGenFunctionInfo,
3174
CIRGenFunctionInfoArgInfo> {
3275
using ArgInfo = CIRGenFunctionInfoArgInfo;
3376

77+
RequiredArgs required;
78+
3479
unsigned numArgs;
3580

3681
ArgInfo *getArgsBuffer() { return getTrailingObjects<ArgInfo>(); }
3782
const ArgInfo *getArgsBuffer() const { return getTrailingObjects<ArgInfo>(); }
3883

84+
CIRGenFunctionInfo() : required(RequiredArgs::All) {}
85+
3986
public:
4087
static CIRGenFunctionInfo *create(CanQualType resultType,
41-
llvm::ArrayRef<CanQualType> argTypes);
88+
llvm::ArrayRef<CanQualType> argTypes,
89+
RequiredArgs required);
4290

4391
void operator delete(void *p) { ::operator delete(p); }
4492

@@ -51,30 +99,45 @@ class CIRGenFunctionInfo final
5199

52100
// This function has to be CamelCase because llvm::FoldingSet requires so.
53101
// NOLINTNEXTLINE(readability-identifier-naming)
54-
static void Profile(llvm::FoldingSetNodeID &id, CanQualType resultType,
55-
llvm::ArrayRef<clang::CanQualType> argTypes) {
102+
static void Profile(llvm::FoldingSetNodeID &id, RequiredArgs required,
103+
CanQualType resultType,
104+
llvm::ArrayRef<CanQualType> argTypes) {
105+
id.AddBoolean(required.getOpaqueData());
56106
resultType.Profile(id);
57-
for (auto i : argTypes)
58-
i.Profile(id);
107+
for (const CanQualType &arg : argTypes)
108+
arg.Profile(id);
59109
}
60110

61-
void Profile(llvm::FoldingSetNodeID &id) { getReturnType().Profile(id); }
62-
63-
llvm::MutableArrayRef<ArgInfo> arguments() {
64-
return llvm::MutableArrayRef<ArgInfo>(arg_begin(), numArgs);
111+
// NOLINTNEXTLINE(readability-identifier-naming)
112+
void Profile(llvm::FoldingSetNodeID &id) {
113+
id.AddBoolean(required.getOpaqueData());
114+
getReturnType().Profile(id);
65115
}
66-
llvm::ArrayRef<ArgInfo> arguments() const {
67-
return llvm::ArrayRef<ArgInfo>(arg_begin(), numArgs);
116+
117+
CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
118+
119+
const_arg_iterator argInfoBegin() const { return getArgsBuffer() + 1; }
120+
const_arg_iterator argInfoEnd() const {
121+
return getArgsBuffer() + 1 + numArgs;
68122
}
123+
arg_iterator argInfoBegin() { return getArgsBuffer() + 1; }
124+
arg_iterator argInfoEnd() { return getArgsBuffer() + 1 + numArgs; }
69125

70-
const_arg_iterator arg_begin() const { return getArgsBuffer() + 1; }
71-
const_arg_iterator arg_end() const { return getArgsBuffer() + 1 + numArgs; }
72-
arg_iterator arg_begin() { return getArgsBuffer() + 1; }
73-
arg_iterator arg_end() { return getArgsBuffer() + 1 + numArgs; }
126+
unsigned argInfoSize() const { return numArgs; }
74127

75-
unsigned arg_size() const { return numArgs; }
128+
llvm::MutableArrayRef<ArgInfo> argInfos() {
129+
return llvm::MutableArrayRef<ArgInfo>(argInfoBegin(), numArgs);
130+
}
131+
llvm::ArrayRef<ArgInfo> argInfos() const {
132+
return llvm::ArrayRef<ArgInfo>(argInfoBegin(), numArgs);
133+
}
76134

77-
CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
135+
bool isVariadic() const { return required.allowsOptionalArgs(); }
136+
RequiredArgs getRequiredArgs() const { return required; }
137+
unsigned getNumRequiredArgs() const {
138+
return isVariadic() ? getRequiredArgs().getNumRequiredArgs()
139+
: argInfoSize();
140+
}
78141
};
79142

80143
} // namespace clang::CIRGen

‎clang/lib/CIR/CodeGen/CIRGenModule.cpp‎

Lines changed: 17 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@
2323
#include "clang/CIR/Dialect/IR/CIRDialect.h"
2424
#include "clang/CIR/MissingFeatures.h"
2525

26+
#include "CIRGenFunctionInfo.h"
2627
#include "mlir/IR/BuiltinOps.h"
2728
#include "mlir/IR/Location.h"
2829
#include "mlir/IR/MLIRContext.h"
@@ -247,8 +248,22 @@ void CIRGenModule::emitGlobalFunctionDefinition(clang::GlobalDecl gd,
247248
"function definition with a non-identifier for a name");
248249
return;
249250
}
250-
cir::FuncType funcType =
251-
cast<cir::FuncType>(convertType(funcDecl->getType()));
251+
252+
cir::FuncType funcType;
253+
// TODO: Move this to arrangeFunctionDeclaration when it is
254+
// implemented.
255+
// When declaring a function without a prototype, always use a
256+
// non-variadic type.
257+
if (CanQual<FunctionNoProtoType> noProto =
258+
funcDecl->getType()
259+
->getCanonicalTypeUnqualified()
260+
.getAs<FunctionNoProtoType>()) {
261+
const CIRGenFunctionInfo &fi = getTypes().arrangeCIRFunctionInfo(
262+
noProto->getReturnType(), {}, RequiredArgs::All);
263+
funcType = getTypes().getFunctionType(fi);
264+
} else {
265+
funcType = cast<cir::FuncType>(convertType(funcDecl->getType()));
266+
}
252267

253268
cir::FuncOp funcOp = dyn_cast_if_present<cir::FuncOp>(op);
254269
if (!funcOp || funcOp.getFunctionType() != funcType) {

‎clang/lib/CIR/CodeGen/CIRGenTypes.cpp‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
#include "CIRGenTypes.h"
22

3+
#include "CIRGenFunctionInfo.h"
34
#include "CIRGenModule.h"
45

56
#include "clang/AST/ASTContext.h"
@@ -73,21 +74,19 @@ mlir::Type CIRGenTypes::convertFunctionTypeInternal(QualType qft) {
7374
return cir::FuncType::get(SmallVector<mlir::Type, 1>{}, cgm.VoidTy);
7475
}
7576

76-
// TODO(CIR): This is a stub of what the final code will be. See the
77-
// implementation of this function and the implementation of class
78-
// CIRGenFunction in the ClangIR incubator project.
79-
77+
const CIRGenFunctionInfo *fi;
8078
if (const auto *fpt = dyn_cast<FunctionProtoType>(ft)) {
81-
SmallVector<mlir::Type> mlirParamTypes;
82-
for (unsigned i = 0; i < fpt->getNumParams(); ++i) {
83-
mlirParamTypes.push_back(convertType(fpt->getParamType(i)));
84-
}
85-
return cir::FuncType::get(
86-
mlirParamTypes, convertType(fpt->getReturnType().getUnqualifiedType()),
87-
fpt->isVariadic());
79+
fi = &arrangeFreeFunctionType(
80+
CanQual<FunctionProtoType>::CreateUnsafe(QualType(fpt, 0)));
81+
} else {
82+
const FunctionNoProtoType *fnpt = cast<FunctionNoProtoType>(ft);
83+
fi = &arrangeFreeFunctionType(
84+
CanQual<FunctionNoProtoType>::CreateUnsafe(QualType(fnpt, 0)));
8885
}
89-
cgm.errorNYI(SourceLocation(), "non-prototype function type", qft);
90-
return cir::FuncType::get(SmallVector<mlir::Type, 1>{}, cgm.VoidTy);
86+
87+
mlir::Type resultType = getFunctionType(*fi);
88+
89+
return resultType;
9190
}
9291

9392
// This is CIR's version of CodeGenTypes::addRecordTypeName. It isn't shareable
@@ -531,14 +530,15 @@ bool CIRGenTypes::isZeroInitializable(const RecordDecl *rd) {
531530
return getCIRGenRecordLayout(rd).isZeroInitializable();
532531
}
533532

534-
const CIRGenFunctionInfo &CIRGenTypes::arrangeCIRFunctionInfo(
535-
CanQualType returnType, llvm::ArrayRef<clang::CanQualType> argTypes) {
533+
const CIRGenFunctionInfo &
534+
CIRGenTypes::arrangeCIRFunctionInfo(CanQualType returnType,
535+
llvm::ArrayRef<CanQualType> argTypes,
536+
RequiredArgs required) {
536537
assert(llvm::all_of(argTypes,
537-
[](CanQualType T) { return T.isCanonicalAsParam(); }));
538-
538+
[](CanQualType t) { return t.isCanonicalAsParam(); }));
539539
// Lookup or create unique function info.
540540
llvm::FoldingSetNodeID id;
541-
CIRGenFunctionInfo::Profile(id, returnType, argTypes);
541+
CIRGenFunctionInfo::Profile(id, required, returnType, argTypes);
542542

543543
void *insertPos = nullptr;
544544
CIRGenFunctionInfo *fi = functionInfos.FindNodeOrInsertPos(id, insertPos);
@@ -548,7 +548,7 @@ const CIRGenFunctionInfo &CIRGenTypes::arrangeCIRFunctionInfo(
548548
assert(!cir::MissingFeatures::opCallCallConv());
549549

550550
// Construction the function info. We co-allocate the ArgInfos.
551-
fi = CIRGenFunctionInfo::create(returnType, argTypes);
551+
fi = CIRGenFunctionInfo::create(returnType, argTypes, required);
552552
functionInfos.InsertNode(fi, insertPos);
553553

554554
return *fi;

‎clang/lib/CIR/CodeGen/CIRGenTypes.h‎

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -127,7 +127,15 @@ class CIRGenTypes {
127127

128128
const CIRGenFunctionInfo &
129129
arrangeCIRFunctionInfo(CanQualType returnType,
130-
llvm::ArrayRef<clang::CanQualType> argTypes);
130+
llvm::ArrayRef<CanQualType> argTypes,
131+
RequiredArgs required);
132+
133+
const CIRGenFunctionInfo &
134+
arrangeFreeFunctionType(CanQual<FunctionProtoType> fpt);
135+
const CIRGenFunctionInfo &
136+
arrangeFreeFunctionType(CanQual<FunctionNoProtoType> fnpt);
137+
138+
cir::FuncType getFunctionType(const CIRGenFunctionInfo &fi);
131139
};
132140

133141
} // namespace clang::CIRGen

‎clang/lib/CIR/CodeGen/TargetInfo.cpp‎

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,8 @@
11
#include "TargetInfo.h"
22
#include "ABIInfo.h"
3-
#include "CIRGenFunctionInfo.h"
4-
#include "clang/CIR/MissingFeatures.h"
53

64
using namespace clang;
75
using namespace clang::CIRGen;
8-
9-
static bool testIfIsVoidTy(QualType ty) {
10-
const auto *builtinTy = ty->getAs<BuiltinType>();
11-
return builtinTy && builtinTy->getKind() == BuiltinType::Void;
12-
}
13-
146
namespace {
157

168
class X8664ABIInfo : public ABIInfo {

0 commit comments

Comments
 (0)