Skip to content

Commit e5f9de8

Browse files
tbaederrtbaederr
authored
[clang][CodeGen][NFC] Make ConstExprEmitter a ConstStmtVisitor (#89041)
No reason for this to not be one. This gets rid of a few const_casts.
1 parent 8838874 commit e5f9de8

File tree

1 file changed

+56
-52
lines changed

1 file changed

+56
-52
lines changed

‎clang/lib/CodeGen/CGExprConstant.cpp

Lines changed: 56 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -564,12 +564,13 @@ class ConstStructBuilder {
564564

565565
public:
566566
static llvm::Constant *BuildStruct(ConstantEmitter &Emitter,
567-
InitListExpr *ILE, QualType StructTy);
567+
const InitListExpr *ILE,
568+
QualType StructTy);
568569
static llvm::Constant *BuildStruct(ConstantEmitter &Emitter,
569570
const APValue &Value, QualType ValTy);
570571
static bool UpdateStruct(ConstantEmitter &Emitter,
571572
ConstantAggregateBuilder &Const, CharUnits Offset,
572-
InitListExpr *Updater);
573+
const InitListExpr *Updater);
573574

574575
private:
575576
ConstStructBuilder(ConstantEmitter &Emitter,
@@ -586,7 +587,7 @@ class ConstStructBuilder {
586587
bool AppendBitField(const FieldDecl *Field, uint64_t FieldOffset,
587588
llvm::ConstantInt *InitExpr, bool AllowOverwrite = false);
588589

589-
bool Build(InitListExpr *ILE, bool AllowOverwrite);
590+
bool Build(const InitListExpr *ILE, bool AllowOverwrite);
590591
bool Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase,
591592
const CXXRecordDecl *VTableClass, CharUnits BaseOffset);
592593
llvm::Constant *Finalize(QualType Ty);
@@ -635,7 +636,7 @@ bool ConstStructBuilder::AppendBitField(
635636
static bool EmitDesignatedInitUpdater(ConstantEmitter &Emitter,
636637
ConstantAggregateBuilder &Const,
637638
CharUnits Offset, QualType Type,
638-
InitListExpr *Updater) {
639+
const InitListExpr *Updater) {
639640
if (Type->isRecordType())
640641
return ConstStructBuilder::UpdateStruct(Emitter, Const, Offset, Updater);
641642

@@ -647,7 +648,7 @@ static bool EmitDesignatedInitUpdater(ConstantEmitter &Emitter,
647648
llvm::Type *ElemTy = Emitter.CGM.getTypes().ConvertTypeForMem(ElemType);
648649

649650
llvm::Constant *FillC = nullptr;
650-
if (Expr *Filler = Updater->getArrayFiller()) {
651+
if (const Expr *Filler = Updater->getArrayFiller()) {
651652
if (!isa<NoInitExpr>(Filler)) {
652653
FillC = Emitter.tryEmitAbstractForMemory(Filler, ElemType);
653654
if (!FillC)
@@ -658,7 +659,7 @@ static bool EmitDesignatedInitUpdater(ConstantEmitter &Emitter,
658659
unsigned NumElementsToUpdate =
659660
FillC ? CAT->getZExtSize() : Updater->getNumInits();
660661
for (unsigned I = 0; I != NumElementsToUpdate; ++I, Offset += ElemSize) {
661-
Expr *Init = nullptr;
662+
const Expr *Init = nullptr;
662663
if (I < Updater->getNumInits())
663664
Init = Updater->getInit(I);
664665

@@ -667,7 +668,7 @@ static bool EmitDesignatedInitUpdater(ConstantEmitter &Emitter,
667668
return false;
668669
} else if (!Init || isa<NoInitExpr>(Init)) {
669670
continue;
670-
} else if (InitListExpr *ChildILE = dyn_cast<InitListExpr>(Init)) {
671+
} else if (const auto *ChildILE = dyn_cast<InitListExpr>(Init)) {
671672
if (!EmitDesignatedInitUpdater(Emitter, Const, Offset, ElemType,
672673
ChildILE))
673674
return false;
@@ -683,7 +684,7 @@ static bool EmitDesignatedInitUpdater(ConstantEmitter &Emitter,
683684
return true;
684685
}
685686

686-
bool ConstStructBuilder::Build(InitListExpr *ILE, bool AllowOverwrite) {
687+
bool ConstStructBuilder::Build(const InitListExpr *ILE, bool AllowOverwrite) {
687688
RecordDecl *RD = ILE->getType()->castAs<RecordType>()->getDecl();
688689
const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
689690

@@ -711,7 +712,7 @@ bool ConstStructBuilder::Build(InitListExpr *ILE, bool AllowOverwrite) {
711712

712713
// Get the initializer. A struct can include fields without initializers,
713714
// we just use explicit null values for them.
714-
Expr *Init = nullptr;
715+
const Expr *Init = nullptr;
715716
if (ElementNo < ILE->getNumInits())
716717
Init = ILE->getInit(ElementNo++);
717718
if (Init && isa<NoInitExpr>(Init))
@@ -879,7 +880,7 @@ llvm::Constant *ConstStructBuilder::Finalize(QualType Type) {
879880
}
880881

881882
llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter,
882-
InitListExpr *ILE,
883+
const InitListExpr *ILE,
883884
QualType ValTy) {
884885
ConstantAggregateBuilder Const(Emitter.CGM);
885886
ConstStructBuilder Builder(Emitter, Const, CharUnits::Zero());
@@ -906,7 +907,8 @@ llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter,
906907

907908
bool ConstStructBuilder::UpdateStruct(ConstantEmitter &Emitter,
908909
ConstantAggregateBuilder &Const,
909-
CharUnits Offset, InitListExpr *Updater) {
910+
CharUnits Offset,
911+
const InitListExpr *Updater) {
910912
return ConstStructBuilder(Emitter, Const, Offset)
911913
.Build(Updater, /*AllowOverwrite*/ true);
912914
}
@@ -1013,8 +1015,8 @@ EmitArrayConstant(CodeGenModule &CGM, llvm::ArrayType *DesiredType,
10131015
//
10141016
// Constant folding is currently missing support for a few features supported
10151017
// here: CK_ToUnion, CK_ReinterpretMemberPointer, and DesignatedInitUpdateExpr.
1016-
class ConstExprEmitter :
1017-
public StmtVisitor<ConstExprEmitter, llvm::Constant*, QualType> {
1018+
class ConstExprEmitter
1019+
: public ConstStmtVisitor<ConstExprEmitter, llvm::Constant *, QualType> {
10181020
CodeGenModule &CGM;
10191021
ConstantEmitter &Emitter;
10201022
llvm::LLVMContext &VMContext;
@@ -1027,43 +1029,42 @@ class ConstExprEmitter :
10271029
// Visitor Methods
10281030
//===--------------------------------------------------------------------===//
10291031

1030-
llvm::Constant *VisitStmt(Stmt *S, QualType T) {
1031-
return nullptr;
1032-
}
1032+
llvm::Constant *VisitStmt(const Stmt *S, QualType T) { return nullptr; }
10331033

1034-
llvm::Constant *VisitConstantExpr(ConstantExpr *CE, QualType T) {
1034+
llvm::Constant *VisitConstantExpr(const ConstantExpr *CE, QualType T) {
10351035
if (llvm::Constant *Result = Emitter.tryEmitConstantExpr(CE))
10361036
return Result;
10371037
return Visit(CE->getSubExpr(), T);
10381038
}
10391039

1040-
llvm::Constant *VisitParenExpr(ParenExpr *PE, QualType T) {
1040+
llvm::Constant *VisitParenExpr(const ParenExpr *PE, QualType T) {
10411041
return Visit(PE->getSubExpr(), T);
10421042
}
10431043

10441044
llvm::Constant *
1045-
VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE,
1045+
VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *PE,
10461046
QualType T) {
10471047
return Visit(PE->getReplacement(), T);
10481048
}
10491049

1050-
llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE,
1050+
llvm::Constant *VisitGenericSelectionExpr(const GenericSelectionExpr *GE,
10511051
QualType T) {
10521052
return Visit(GE->getResultExpr(), T);
10531053
}
10541054

1055-
llvm::Constant *VisitChooseExpr(ChooseExpr *CE, QualType T) {
1055+
llvm::Constant *VisitChooseExpr(const ChooseExpr *CE, QualType T) {
10561056
return Visit(CE->getChosenSubExpr(), T);
10571057
}
10581058

1059-
llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E, QualType T) {
1059+
llvm::Constant *VisitCompoundLiteralExpr(const CompoundLiteralExpr *E,
1060+
QualType T) {
10601061
return Visit(E->getInitializer(), T);
10611062
}
10621063

1063-
llvm::Constant *VisitCastExpr(CastExpr *E, QualType destType) {
1064+
llvm::Constant *VisitCastExpr(const CastExpr *E, QualType destType) {
10641065
if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
10651066
CGM.EmitExplicitCastExprType(ECE, Emitter.CGF);
1066-
Expr *subExpr = E->getSubExpr();
1067+
const Expr *subExpr = E->getSubExpr();
10671068

10681069
switch (E->getCastKind()) {
10691070
case CK_ToUnion: {
@@ -1117,7 +1118,8 @@ class ConstExprEmitter :
11171118
// interesting conversions should be done in Evaluate(). But as a
11181119
// special case, allow compound literals to support the gcc extension
11191120
// allowing "struct x {int x;} x = (struct x) {};".
1120-
if (auto *E = dyn_cast<CompoundLiteralExpr>(subExpr->IgnoreParens()))
1121+
if (const auto *E =
1122+
dyn_cast<CompoundLiteralExpr>(subExpr->IgnoreParens()))
11211123
return Visit(E->getInitializer(), destType);
11221124
return nullptr;
11231125
}
@@ -1232,21 +1234,22 @@ class ConstExprEmitter :
12321234
llvm_unreachable("Invalid CastKind");
12331235
}
12341236

1235-
llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE, QualType T) {
1237+
llvm::Constant *VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *DIE,
1238+
QualType T) {
12361239
// No need for a DefaultInitExprScope: we don't handle 'this' in a
12371240
// constant expression.
12381241
return Visit(DIE->getExpr(), T);
12391242
}
12401243

1241-
llvm::Constant *VisitExprWithCleanups(ExprWithCleanups *E, QualType T) {
1244+
llvm::Constant *VisitExprWithCleanups(const ExprWithCleanups *E, QualType T) {
12421245
return Visit(E->getSubExpr(), T);
12431246
}
12441247

1245-
llvm::Constant *VisitIntegerLiteral(IntegerLiteral *I, QualType T) {
1248+
llvm::Constant *VisitIntegerLiteral(const IntegerLiteral *I, QualType T) {
12461249
return llvm::ConstantInt::get(CGM.getLLVMContext(), I->getValue());
12471250
}
12481251

1249-
llvm::Constant *EmitArrayInitialization(InitListExpr *ILE, QualType T) {
1252+
llvm::Constant *EmitArrayInitialization(const InitListExpr *ILE, QualType T) {
12501253
auto *CAT = CGM.getContext().getAsConstantArrayType(ILE->getType());
12511254
assert(CAT && "can't emit array init for non-constant-bound array");
12521255
unsigned NumInitElements = ILE->getNumInits();
@@ -1260,7 +1263,7 @@ class ConstExprEmitter :
12601263

12611264
// Initialize remaining array elements.
12621265
llvm::Constant *fillC = nullptr;
1263-
if (Expr *filler = ILE->getArrayFiller()) {
1266+
if (const Expr *filler = ILE->getArrayFiller()) {
12641267
fillC = Emitter.tryEmitAbstractForMemory(filler, EltType);
12651268
if (!fillC)
12661269
return nullptr;
@@ -1275,7 +1278,7 @@ class ConstExprEmitter :
12751278

12761279
llvm::Type *CommonElementType = nullptr;
12771280
for (unsigned i = 0; i < NumInitableElts; ++i) {
1278-
Expr *Init = ILE->getInit(i);
1281+
const Expr *Init = ILE->getInit(i);
12791282
llvm::Constant *C = Emitter.tryEmitPrivateForMemory(Init, EltType);
12801283
if (!C)
12811284
return nullptr;
@@ -1292,16 +1295,17 @@ class ConstExprEmitter :
12921295
fillC);
12931296
}
12941297

1295-
llvm::Constant *EmitRecordInitialization(InitListExpr *ILE, QualType T) {
1298+
llvm::Constant *EmitRecordInitialization(const InitListExpr *ILE,
1299+
QualType T) {
12961300
return ConstStructBuilder::BuildStruct(Emitter, ILE, T);
12971301
}
12981302

1299-
llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E,
1303+
llvm::Constant *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E,
13001304
QualType T) {
13011305
return CGM.EmitNullConstant(T);
13021306
}
13031307

1304-
llvm::Constant *VisitInitListExpr(InitListExpr *ILE, QualType T) {
1308+
llvm::Constant *VisitInitListExpr(const InitListExpr *ILE, QualType T) {
13051309
if (ILE->isTransparent())
13061310
return Visit(ILE->getInit(0), T);
13071311

@@ -1314,8 +1318,9 @@ class ConstExprEmitter :
13141318
return nullptr;
13151319
}
13161320

1317-
llvm::Constant *VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E,
1318-
QualType destType) {
1321+
llvm::Constant *
1322+
VisitDesignatedInitUpdateExpr(const DesignatedInitUpdateExpr *E,
1323+
QualType destType) {
13191324
auto C = Visit(E->getBase(), destType);
13201325
if (!C)
13211326
return nullptr;
@@ -1329,12 +1334,13 @@ class ConstExprEmitter :
13291334

13301335
llvm::Type *ValTy = CGM.getTypes().ConvertType(destType);
13311336
bool HasFlexibleArray = false;
1332-
if (auto *RT = destType->getAs<RecordType>())
1337+
if (const auto *RT = destType->getAs<RecordType>())
13331338
HasFlexibleArray = RT->getDecl()->hasFlexibleArrayMember();
13341339
return Const.build(ValTy, HasFlexibleArray);
13351340
}
13361341

1337-
llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E, QualType Ty) {
1342+
llvm::Constant *VisitCXXConstructExpr(const CXXConstructExpr *E,
1343+
QualType Ty) {
13381344
if (!E->getConstructor()->isTrivial())
13391345
return nullptr;
13401346

@@ -1344,13 +1350,13 @@ class ConstExprEmitter :
13441350
assert(E->getConstructor()->isCopyOrMoveConstructor() &&
13451351
"trivial ctor has argument but isn't a copy/move ctor");
13461352

1347-
Expr *Arg = E->getArg(0);
1353+
const Expr *Arg = E->getArg(0);
13481354
assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) &&
13491355
"argument to copy ctor is of wrong type");
13501356

13511357
// Look through the temporary; it's just converting the value to an
13521358
// lvalue to pass it to the constructor.
1353-
if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Arg))
1359+
if (const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Arg))
13541360
return Visit(MTE->getSubExpr(), Ty);
13551361
// Don't try to support arbitrary lvalue-to-rvalue conversions for now.
13561362
return nullptr;
@@ -1359,12 +1365,12 @@ class ConstExprEmitter :
13591365
return CGM.EmitNullConstant(Ty);
13601366
}
13611367

1362-
llvm::Constant *VisitStringLiteral(StringLiteral *E, QualType T) {
1368+
llvm::Constant *VisitStringLiteral(const StringLiteral *E, QualType T) {
13631369
// This is a string literal initializing an array in an initializer.
13641370
return CGM.GetConstantArrayFromStringLiteral(E);
13651371
}
13661372

1367-
llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E, QualType T) {
1373+
llvm::Constant *VisitObjCEncodeExpr(const ObjCEncodeExpr *E, QualType T) {
13681374
// This must be an @encode initializing an array in a static initializer.
13691375
// Don't emit it as the address of the string, emit the string data itself
13701376
// as an inline array.
@@ -1383,14 +1389,14 @@ class ConstExprEmitter :
13831389
return Visit(E->getSubExpr(), T);
13841390
}
13851391

1386-
llvm::Constant *VisitUnaryMinus(UnaryOperator *U, QualType T) {
1392+
llvm::Constant *VisitUnaryMinus(const UnaryOperator *U, QualType T) {
13871393
if (llvm::Constant *C = Visit(U->getSubExpr(), T))
13881394
if (auto *CI = dyn_cast<llvm::ConstantInt>(C))
13891395
return llvm::ConstantInt::get(CGM.getLLVMContext(), -CI->getValue());
13901396
return nullptr;
13911397
}
13921398

1393-
llvm::Constant *VisitPackIndexingExpr(PackIndexingExpr *E, QualType T) {
1399+
llvm::Constant *VisitPackIndexingExpr(const PackIndexingExpr *E, QualType T) {
13941400
return Visit(E->getSelectedExpr(), T);
13951401
}
13961402

@@ -1696,8 +1702,7 @@ llvm::Constant *ConstantEmitter::tryEmitPrivateForVarInit(const VarDecl &D) {
16961702

16971703
if (!destType->isReferenceType()) {
16981704
QualType nonMemoryDestType = getNonMemoryType(CGM, destType);
1699-
if (llvm::Constant *C = ConstExprEmitter(*this).Visit(const_cast<Expr *>(E),
1700-
nonMemoryDestType))
1705+
if (llvm::Constant *C = ConstExprEmitter(*this).Visit(E, nonMemoryDestType))
17011706
return emitForMemory(C, destType);
17021707
}
17031708

@@ -1777,8 +1782,7 @@ llvm::Constant *ConstantEmitter::tryEmitPrivate(const Expr *E,
17771782
assert(!destType->isVoidType() && "can't emit a void constant");
17781783

17791784
if (!destType->isReferenceType())
1780-
if (llvm::Constant *C =
1781-
ConstExprEmitter(*this).Visit(const_cast<Expr *>(E), destType))
1785+
if (llvm::Constant *C = ConstExprEmitter(*this).Visit(E, destType))
17821786
return C;
17831787

17841788
Expr::EvalResult Result;
@@ -2022,7 +2026,7 @@ ConstantLValue
20222026
ConstantLValueEmitter::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
20232027
assert(E->isExpressibleAsConstantInitializer() &&
20242028
"this boxed expression can't be emitted as a compile-time constant");
2025-
auto *SL = cast<StringLiteral>(E->getSubExpr()->IgnoreParenCasts());
2029+
const auto *SL = cast<StringLiteral>(E->getSubExpr()->IgnoreParenCasts());
20262030
return emitConstantObjCStringLiteral(SL, E->getType(), CGM);
20272031
}
20282032

@@ -2048,12 +2052,12 @@ ConstantLValueEmitter::VisitCallExpr(const CallExpr *E) {
20482052
builtin != Builtin::BI__builtin___NSStringMakeConstantString)
20492053
return nullptr;
20502054

2051-
auto literal = cast<StringLiteral>(E->getArg(0)->IgnoreParenCasts());
2055+
const auto *Literal = cast<StringLiteral>(E->getArg(0)->IgnoreParenCasts());
20522056
if (builtin == Builtin::BI__builtin___NSStringMakeConstantString) {
2053-
return CGM.getObjCRuntime().GenerateConstantString(literal);
2057+
return CGM.getObjCRuntime().GenerateConstantString(Literal);
20542058
} else {
20552059
// FIXME: need to deal with UCN conversion issues.
2056-
return CGM.GetAddrOfConstantCFString(literal);
2060+
return CGM.GetAddrOfConstantCFString(Literal);
20572061
}
20582062
}
20592063

0 commit comments

Comments
 (0)