[llvm] [NFC][TableGen] Use auto when initializing variables with cast<> (PR #113171)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Oct 21 10:29:39 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-tablegen
Author: Rahul Joshi (jurahul)
<details>
<summary>Changes</summary>
Use `auto` when initializing a variable with `cast<>`. Remove some unneeded `const_cast` (since all Init pointers are now const).
---
Patch is 73.50 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/113171.diff
4 Files Affected:
- (modified) llvm/include/llvm/TableGen/Record.h (+4-8)
- (modified) llvm/lib/TableGen/Record.cpp (+163-165)
- (modified) llvm/lib/TableGen/SetTheory.cpp (+1-1)
- (modified) llvm/lib/TableGen/TGParser.cpp (+75-75)
``````````diff
diff --git a/llvm/include/llvm/TableGen/Record.h b/llvm/include/llvm/TableGen/Record.h
index 63267b7633f6cf..78b44cfc649a5c 100644
--- a/llvm/include/llvm/TableGen/Record.h
+++ b/llvm/include/llvm/TableGen/Record.h
@@ -401,9 +401,7 @@ class Init {
/// variables which may not be defined at the time the expression is formed.
/// If a value is set for the variable later, this method will be called on
/// users of the value to allow the value to propagate out.
- virtual const Init *resolveReferences(Resolver &R) const {
- return const_cast<Init *>(this);
- }
+ virtual const Init *resolveReferences(Resolver &R) const { return this; }
/// Get the \p Init value of the specified bit.
virtual const Init *getBit(unsigned Bit) const = 0;
@@ -475,9 +473,7 @@ class UnsetInit : public Init {
const Init *getCastTo(const RecTy *Ty) const override;
const Init *convertInitializerTo(const RecTy *Ty) const override;
- const Init *getBit(unsigned Bit) const override {
- return const_cast<UnsetInit*>(this);
- }
+ const Init *getBit(unsigned Bit) const override { return this; }
/// Is this a complete value with no unset (uninitialized) subvalues?
bool isComplete() const override { return false; }
@@ -579,7 +575,7 @@ class BitInit final : public TypedInit {
const Init *getBit(unsigned Bit) const override {
assert(Bit < 1 && "Bit index out of range!");
- return const_cast<BitInit*>(this);
+ return this;
}
bool isConcrete() const override { return true; }
@@ -1318,7 +1314,7 @@ class VarBitInit final : public TypedInit {
const Init *getBit(unsigned B) const override {
assert(B < 1 && "Bit index out of range!");
- return const_cast<VarBitInit*>(this);
+ return this;
}
};
diff --git a/llvm/lib/TableGen/Record.cpp b/llvm/lib/TableGen/Record.cpp
index f8ea88375c48ea..9241fb3d8e72d9 100644
--- a/llvm/lib/TableGen/Record.cpp
+++ b/llvm/lib/TableGen/Record.cpp
@@ -156,7 +156,7 @@ const BitRecTy *BitRecTy::get(RecordKeeper &RK) {
bool BitRecTy::typeIsConvertibleTo(const RecTy *RHS) const{
if (RecTy::typeIsConvertibleTo(RHS) || RHS->getRecTyKind() == IntRecTyKind)
return true;
- if (const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS))
+ if (const auto *BitsTy = dyn_cast<BitsRecTy>(RHS))
return BitsTy->getNumBits() == 1;
return false;
}
@@ -215,7 +215,7 @@ bool ListRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
}
bool ListRecTy::typeIsA(const RecTy *RHS) const {
- if (const ListRecTy *RHSl = dyn_cast<ListRecTy>(RHS))
+ if (const auto *RHSl = dyn_cast<ListRecTy>(RHS))
return getElementType()->typeIsA(RHSl->getElementType());
return false;
}
@@ -309,7 +309,7 @@ bool RecordRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
if (this == RHS)
return true;
- const RecordRecTy *RTy = dyn_cast<RecordRecTy>(RHS);
+ const auto *RTy = dyn_cast<RecordRecTy>(RHS);
if (!RTy)
return false;
@@ -344,8 +344,8 @@ const RecTy *llvm::resolveTypes(const RecTy *T1, const RecTy *T2) {
if (T1 == T2)
return T1;
- if (const RecordRecTy *RecTy1 = dyn_cast<RecordRecTy>(T1)) {
- if (const RecordRecTy *RecTy2 = dyn_cast<RecordRecTy>(T2))
+ if (const auto *RecTy1 = dyn_cast<RecordRecTy>(T1)) {
+ if (const auto *RecTy2 = dyn_cast<RecordRecTy>(T2))
return resolveRecordTypes(RecTy1, RecTy2);
}
@@ -357,8 +357,8 @@ const RecTy *llvm::resolveTypes(const RecTy *T1, const RecTy *T2) {
if (T2->typeIsConvertibleTo(T1))
return T1;
- if (const ListRecTy *ListTy1 = dyn_cast<ListRecTy>(T1)) {
- if (const ListRecTy *ListTy2 = dyn_cast<ListRecTy>(T2)) {
+ if (const auto *ListTy1 = dyn_cast<ListRecTy>(T1)) {
+ if (const auto *ListTy2 = dyn_cast<ListRecTy>(T2)) {
const RecTy *NewType =
resolveTypes(ListTy1->getElementType(), ListTy2->getElementType());
if (NewType)
@@ -433,7 +433,7 @@ const Init *ArgumentInit::resolveReferences(Resolver &R) const {
if (NewValue != Value)
return cloneWithValue(NewValue);
- return const_cast<ArgumentInit *>(this);
+ return this;
}
BitInit *BitInit::get(RecordKeeper &RK, bool V) {
@@ -442,7 +442,7 @@ BitInit *BitInit::get(RecordKeeper &RK, bool V) {
const Init *BitInit::convertInitializerTo(const RecTy *Ty) const {
if (isa<BitRecTy>(Ty))
- return const_cast<BitInit *>(this);
+ return this;
if (isa<IntRecTy>(Ty))
return IntInit::get(getRecordKeeper(), getValue());
@@ -450,7 +450,7 @@ const Init *BitInit::convertInitializerTo(const RecTy *Ty) const {
if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
// Can only convert single bit.
if (BRT->getNumBits() == 1)
- return BitsInit::get(getRecordKeeper(), const_cast<BitInit *>(this));
+ return BitsInit::get(getRecordKeeper(), this);
}
return nullptr;
@@ -496,7 +496,7 @@ const Init *BitsInit::convertInitializerTo(const RecTy *Ty) const {
// If the number of bits is right, return it. Otherwise we need to expand
// or truncate.
if (getNumBits() != BRT->getNumBits()) return nullptr;
- return const_cast<BitsInit *>(this);
+ return this;
}
if (isa<IntRecTy>(Ty)) {
@@ -563,7 +563,7 @@ const Init *BitsInit::resolveReferences(Resolver &R) const {
const Init *CurBit = getBit(i);
const Init *NewBit = CurBit;
- if (const VarBitInit *CurBitVar = dyn_cast<VarBitInit>(CurBit)) {
+ if (const auto *CurBitVar = dyn_cast<VarBitInit>(CurBit)) {
if (CurBitVar->getBitVar() != CachedBitVarRef) {
CachedBitVarRef = CurBitVar->getBitVar();
CachedBitVarResolved = CachedBitVarRef->resolveReferences(R);
@@ -606,7 +606,7 @@ static bool canFitInBitfield(int64_t Value, unsigned NumBits) {
const Init *IntInit::convertInitializerTo(const RecTy *Ty) const {
if (isa<IntRecTy>(Ty))
- return const_cast<IntInit *>(this);
+ return this;
if (isa<BitRecTy>(Ty)) {
int64_t Val = getValue();
@@ -614,7 +614,7 @@ const Init *IntInit::convertInitializerTo(const RecTy *Ty) const {
return BitInit::get(getRecordKeeper(), Val != 0);
}
- if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
+ if (const auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
int64_t Value = getValue();
// Make sure this bitfield is large enough to hold the integer value.
if (!canFitInBitfield(Value, BRT->getNumBits()))
@@ -657,11 +657,11 @@ std::string AnonymousNameInit::getAsString() const {
}
const Init *AnonymousNameInit::resolveReferences(Resolver &R) const {
- auto *Old = const_cast<Init *>(static_cast<const Init *>(this));
+ auto *Old = this;
auto *New = R.resolve(Old);
New = New ? New : Old;
if (R.isFinal())
- if (auto *Anonymous = dyn_cast<AnonymousNameInit>(New))
+ if (const auto *Anonymous = dyn_cast<AnonymousNameInit>(New))
return Anonymous->getNameInit();
return New;
}
@@ -679,7 +679,7 @@ const StringInit *StringInit::get(RecordKeeper &RK, StringRef V,
const Init *StringInit::convertInitializerTo(const RecTy *Ty) const {
if (isa<StringRecTy>(Ty))
- return const_cast<StringInit *>(this);
+ return this;
return nullptr;
}
@@ -723,9 +723,9 @@ void ListInit::Profile(FoldingSetNodeID &ID) const {
const Init *ListInit::convertInitializerTo(const RecTy *Ty) const {
if (getType() == Ty)
- return const_cast<ListInit*>(this);
+ return this;
- if (auto *LRT = dyn_cast<ListRecTy>(Ty)) {
+ if (const auto *LRT = dyn_cast<ListRecTy>(Ty)) {
SmallVector<const Init *, 8> Elements;
Elements.reserve(getValues().size());
@@ -742,7 +742,7 @@ const Init *ListInit::convertInitializerTo(const RecTy *Ty) const {
return nullptr;
if (!Changed)
- return const_cast<ListInit*>(this);
+ return this;
return ListInit::get(Elements, ElementType);
}
@@ -751,7 +751,7 @@ const Init *ListInit::convertInitializerTo(const RecTy *Ty) const {
const Record *ListInit::getElementAsRecord(unsigned i) const {
assert(i < NumValues && "List element index out of range!");
- const DefInit *DI = dyn_cast<DefInit>(getElement(i));
+ const auto *DI = dyn_cast<DefInit>(getElement(i));
if (!DI)
PrintFatalError("Expected record in list!");
return DI->getDef();
@@ -802,7 +802,7 @@ std::string ListInit::getAsString() const {
const Init *OpInit::getBit(unsigned Bit) const {
if (getType() == BitRecTy::get(getRecordKeeper()))
- return const_cast<OpInit*>(this);
+ return this;
return VarBitInit::get(this, Bit);
}
@@ -853,27 +853,27 @@ const Init *UnOpInit::Fold(const Record *CurRec, bool IsFinal) const {
}
break;
case TOLOWER:
- if (const StringInit *LHSs = dyn_cast<StringInit>(LHS))
+ if (const auto *LHSs = dyn_cast<StringInit>(LHS))
return StringInit::get(RK, LHSs->getValue().lower());
break;
case TOUPPER:
- if (const StringInit *LHSs = dyn_cast<StringInit>(LHS))
+ if (const auto *LHSs = dyn_cast<StringInit>(LHS))
return StringInit::get(RK, LHSs->getValue().upper());
break;
case CAST:
if (isa<StringRecTy>(getType())) {
- if (const StringInit *LHSs = dyn_cast<StringInit>(LHS))
+ if (const auto *LHSs = dyn_cast<StringInit>(LHS))
return LHSs;
- if (const DefInit *LHSd = dyn_cast<DefInit>(LHS))
+ if (const auto *LHSd = dyn_cast<DefInit>(LHS))
return StringInit::get(RK, LHSd->getAsString());
- if (const IntInit *LHSi = dyn_cast_or_null<IntInit>(
+ if (const auto *LHSi = dyn_cast_or_null<IntInit>(
LHS->convertInitializerTo(IntRecTy::get(RK))))
return StringInit::get(RK, LHSi->getAsString());
} else if (isa<RecordRecTy>(getType())) {
- if (const StringInit *Name = dyn_cast<StringInit>(LHS)) {
+ if (const auto *Name = dyn_cast<StringInit>(LHS)) {
const Record *D = RK.getDef(Name->getValue());
if (!D && CurRec) {
// Self-references are allowed, but their resolution is delayed until
@@ -918,20 +918,20 @@ const Init *UnOpInit::Fold(const Record *CurRec, bool IsFinal) const {
break;
case NOT:
- if (const IntInit *LHSi = dyn_cast_or_null<IntInit>(
+ if (const auto *LHSi = dyn_cast_or_null<IntInit>(
LHS->convertInitializerTo(IntRecTy::get(RK))))
return IntInit::get(RK, LHSi->getValue() ? 0 : 1);
break;
case HEAD:
- if (const ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
+ if (const auto *LHSl = dyn_cast<ListInit>(LHS)) {
assert(!LHSl->empty() && "Empty list in head");
return LHSl->getElement(0);
}
break;
case TAIL:
- if (const ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
+ if (const auto *LHSl = dyn_cast<ListInit>(LHS)) {
assert(!LHSl->empty() && "Empty list in tail");
// Note the +1. We can't just pass the result of getValues()
// directly.
@@ -940,25 +940,25 @@ const Init *UnOpInit::Fold(const Record *CurRec, bool IsFinal) const {
break;
case SIZE:
- if (const ListInit *LHSl = dyn_cast<ListInit>(LHS))
+ if (const auto *LHSl = dyn_cast<ListInit>(LHS))
return IntInit::get(RK, LHSl->size());
- if (const DagInit *LHSd = dyn_cast<DagInit>(LHS))
+ if (const auto *LHSd = dyn_cast<DagInit>(LHS))
return IntInit::get(RK, LHSd->arg_size());
- if (const StringInit *LHSs = dyn_cast<StringInit>(LHS))
+ if (const auto *LHSs = dyn_cast<StringInit>(LHS))
return IntInit::get(RK, LHSs->getValue().size());
break;
case EMPTY:
- if (const ListInit *LHSl = dyn_cast<ListInit>(LHS))
+ if (const auto *LHSl = dyn_cast<ListInit>(LHS))
return IntInit::get(RK, LHSl->empty());
- if (const DagInit *LHSd = dyn_cast<DagInit>(LHS))
+ if (const auto *LHSd = dyn_cast<DagInit>(LHS))
return IntInit::get(RK, LHSd->arg_empty());
- if (const StringInit *LHSs = dyn_cast<StringInit>(LHS))
+ if (const auto *LHSs = dyn_cast<StringInit>(LHS))
return IntInit::get(RK, LHSs->getValue().empty());
break;
case GETDAGOP:
- if (const DagInit *Dag = dyn_cast<DagInit>(LHS)) {
+ if (const auto *Dag = dyn_cast<DagInit>(LHS)) {
// TI is not necessarily a def due to the late resolution in multiclasses,
// but has to be a TypedInit.
auto *TI = cast<TypedInit>(Dag->getOperator());
@@ -974,7 +974,7 @@ const Init *UnOpInit::Fold(const Record *CurRec, bool IsFinal) const {
break;
case LOG2:
- if (const IntInit *LHSi = dyn_cast_or_null<IntInit>(
+ if (const auto *LHSi = dyn_cast_or_null<IntInit>(
LHS->convertInitializerTo(IntRecTy::get(RK)))) {
int64_t LHSv = LHSi->getValue();
if (LHSv <= 0) {
@@ -991,9 +991,8 @@ const Init *UnOpInit::Fold(const Record *CurRec, bool IsFinal) const {
break;
case LISTFLATTEN:
- if (const ListInit *LHSList = dyn_cast<ListInit>(LHS)) {
- const ListRecTy *InnerListTy =
- dyn_cast<ListRecTy>(LHSList->getElementType());
+ if (const auto *LHSList = dyn_cast<ListInit>(LHS)) {
+ const auto *InnerListTy = dyn_cast<ListRecTy>(LHSList->getElementType());
// list of non-lists, !listflatten() is a NOP.
if (!InnerListTy)
return LHS;
@@ -1003,7 +1002,7 @@ const Init *UnOpInit::Fold(const Record *CurRec, bool IsFinal) const {
std::vector<const Init *> Flattened;
// Concatenate elements of all the inner lists.
for (const Init *InnerInit : List->getValues()) {
- const ListInit *InnerList = dyn_cast<ListInit>(InnerInit);
+ const auto *InnerList = dyn_cast<ListInit>(InnerInit);
if (!InnerList)
return std::nullopt;
for (const Init *InnerElem : InnerList->getValues())
@@ -1018,7 +1017,7 @@ const Init *UnOpInit::Fold(const Record *CurRec, bool IsFinal) const {
}
break;
}
- return const_cast<UnOpInit *>(this);
+ return this;
}
const Init *UnOpInit::resolveReferences(Resolver &R) const {
@@ -1098,7 +1097,7 @@ static const StringInit *interleaveStringList(const ListInit *List,
const StringInit *Delim) {
if (List->size() == 0)
return StringInit::get(List->getRecordKeeper(), "");
- const StringInit *Element = dyn_cast<StringInit>(List->getElement(0));
+ const auto *Element = dyn_cast<StringInit>(List->getElement(0));
if (!Element)
return nullptr;
SmallString<80> Result(Element->getValue());
@@ -1106,7 +1105,7 @@ static const StringInit *interleaveStringList(const ListInit *List,
for (unsigned I = 1, E = List->size(); I < E; ++I) {
Result.append(Delim->getValue());
- const StringInit *Element = dyn_cast<StringInit>(List->getElement(I));
+ const auto *Element = dyn_cast<StringInit>(List->getElement(I));
if (!Element)
return nullptr;
Result.append(Element->getValue());
@@ -1120,7 +1119,7 @@ static const StringInit *interleaveIntList(const ListInit *List,
RecordKeeper &RK = List->getRecordKeeper();
if (List->size() == 0)
return StringInit::get(RK, "");
- const IntInit *Element = dyn_cast_or_null<IntInit>(
+ const auto *Element = dyn_cast_or_null<IntInit>(
List->getElement(0)->convertInitializerTo(IntRecTy::get(RK)));
if (!Element)
return nullptr;
@@ -1128,7 +1127,7 @@ static const StringInit *interleaveIntList(const ListInit *List,
for (unsigned I = 1, E = List->size(); I < E; ++I) {
Result.append(Delim->getValue());
- const IntInit *Element = dyn_cast_or_null<IntInit>(
+ const auto *Element = dyn_cast_or_null<IntInit>(
List->getElement(I)->convertInitializerTo(IntRecTy::get(RK)));
if (!Element)
return nullptr;
@@ -1139,8 +1138,8 @@ static const StringInit *interleaveIntList(const ListInit *List,
const Init *BinOpInit::getStrConcat(const Init *I0, const Init *I1) {
// Shortcut for the common case of concatenating two strings.
- if (const StringInit *I0s = dyn_cast<StringInit>(I0))
- if (const StringInit *I1s = dyn_cast<StringInit>(I1))
+ if (const auto *I0s = dyn_cast<StringInit>(I0))
+ if (const auto *I1s = dyn_cast<StringInit>(I1))
return ConcatStringInits(I0s, I1s);
return BinOpInit::get(BinOpInit::STRCONCAT, I0, I1,
StringRecTy::get(I0->getRecordKeeper()));
@@ -1158,8 +1157,8 @@ const Init *BinOpInit::getListConcat(const TypedInit *LHS, const Init *RHS) {
assert(isa<ListRecTy>(LHS->getType()) && "First arg must be a list");
// Shortcut for the common case of concatenating two lists.
- if (const ListInit *LHSList = dyn_cast<ListInit>(LHS))
- if (const ListInit *RHSList = dyn_cast<ListInit>(RHS))
+ if (const auto *LHSList = dyn_cast<ListInit>(LHS))
+ if (const auto *RHSList = dyn_cast<ListInit>(RHS))
return ConcatListInits(LHSList, RHSList);
return BinOpInit::get(BinOpInit::LISTCONCAT, LHS, RHS, LHS->getType());
}
@@ -1167,9 +1166,9 @@ const Init *BinOpInit::getListConcat(const TypedInit *LHS, const Init *RHS) {
std::optional<bool> BinOpInit::CompareInit(unsigned Opc, const Init *LHS,
const Init *RHS) const {
// First see if we have two bit, bits, or int.
- const IntInit *LHSi = dyn_cast_or_null<IntInit>(
+ const auto *LHSi = dyn_cast_or_null<IntInit>(
LHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
- const IntInit *RHSi = dyn_cast_or_null<IntInit>(
+ const auto *RHSi = dyn_cast_or_null<IntInit>(
RHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
if (LHSi && RHSi) {
@@ -1200,8 +1199,8 @@ std::optional<bool> BinOpInit::CompareInit(unsigned Opc, const Init *LHS,
}
// Next try strings.
- const StringInit *LHSs = dyn_cast<StringInit>(LHS);
- const StringInit *RHSs = dyn_cast<StringInit>(RHS);
+ const auto *LHSs = dyn_cast<StringInit>(LHS);
+ const auto *RHSs = dyn_cast<StringInit>(RHS);
if (LHSs && RHSs) {
bool Result;
@@ -1232,8 +1231,8 @@ std::optional<bool> BinOpInit::CompareInit(unsigned Opc, const Init *LHS,
// Finally, !eq and !ne can be used with records.
if (Opc == EQ || Opc == NE) {
- const DefInit *LHSd = dyn_cast<DefInit>(LHS);
- const DefInit *RHSd = dyn_cast<DefInit>(RHS);
+ const auto *LHSd = dyn_cast<DefInit>(LHS);
+ const auto *RHSd = dyn_cast<DefInit>(RHS);
if (LHSd && RHSd)
return (Opc == EQ) ? LHSd == RHSd : LHSd != RHSd;
}
@@ -1244,7 +1243,7 @@ std::optional<bool> BinOpInit::CompareInit(unsigned Opc, const Init *LHS,
static std::optional<unsigned>
getDagArgNoByKey(const DagInit *Dag, const Init *Key, std::string &Error) {
// Accessor by index
- if (const IntInit *Idx = dyn_cast<IntInit>(Key)) {
+ if (const auto *Idx = dyn_cast<IntInit>(Key)) {
int64_t Pos = Idx->getValue();
if (Pos < 0) {
// The index is negative.
@@ -1264,7 +1263,7 @@ getDagArgNoByKey(const DagInit *Dag, const Init *Key, std::string &Error) {
}
assert(isa<StringInit>(Key));
// Accessor by name
- const StringInit *Name = dyn_cast<StringInit>(Key);
+ const auto *Name = dyn_cast<StringInit>(Key);
auto ArgNo = Dag->getArgNo(Name->getValue());
if (!ArgNo) {
// The key is not found.
@@ -1277,11 +1276,11 @@ getDagArgNoByKey(const DagInit *Dag, const Init *Key, std::string &Error) {
const Init *BinOpInit::Fold(const Record *CurRec) const {
switch (getOpcode()) {
case CONCAT: {
- const DagInit *LHSs = dyn_cast<DagInit>(LHS);
- const DagInit *RHSs = dyn_cast<DagInit>(RHS);
+ const auto *LHSs = dyn_cast<DagInit>(LHS);
+ const auto *RHSs = dyn_cast<DagInit>(RHS);
if (LHSs && RHSs) {
- const DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator());
- const DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator());
+ const auto *LOp = dyn_cast<DefInit>(LHSs->getOperator());
+ const auto *ROp = dyn_cast<DefInit>(RHSs->getOperator());
if ((!LOp && !isa<UnsetInit>(LHSs->getOperator())) ||
(!ROp && !isa<UnsetInit>(RHSs->getOperator())))
break;
@@ -1309,8 +1308,8 @@ const Init *BinOpInit::Fold(const Record *CurRec) const {
break;
}
case LISTCONCAT: {
- const ListInit *LHSs = dyn_cast<ListInit>(LHS);
- const ListInit *RHSs = dyn_cast<ListInit>(RHS);
+ const auto *LHSs = dyn_cast<ListInit>(LHS);
+ const auto *RHSs = dyn_cast<ListInit>(RHS);
if (LHSs && RHSs) {
SmallVector<const Init *, 8> Args;
llvm::append_range(Args, *LHSs);
@@ -1320,8 +1319,8 @@ const Init *BinOpInit::Fold(const Record *CurRec) const {
break;
}
case LISTSPLAT: {
- const Typed...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/113171
More information about the llvm-commits
mailing list