================
@@ -2361,6 +2361,99 @@ static bool DiagnoseHLSLRegisterAttribute(Sema &S,
SourceLocation &ArgLoc,
return ValidateMultipleRegisterAnnotations(S, D, RegType);
}
+bool ExceedsUInt32Max(llvm::StringRef S) {
+ constexpr size_t MaxDigits = 10; // UINT32_MAX = 4294967295
+ if (S.size() > MaxDigits)
+ return true;
+
+ if (S.size() < MaxDigits)
+ return false;
+
+ return S.compare("4294967295") > 0;
+}
+
+// return false if the slot count exceeds the limit, true otherwise
+static bool AccumulateHLSLResourceSlots(QualType Ty, llvm::APInt &SlotCount,
+ const llvm::APInt &Limit,
+ ASTContext &Ctx,
+ uint64_t Multiplier = 1) {
+ Ty = Ty.getCanonicalType();
+ const Type *T = Ty.getTypePtr();
+
+ // Early exit if already overflowed
+ if (SlotCount.ugt(Limit))
+ return false;
+
+ // Case 1: array type
+ if (const auto *AT = dyn_cast<ArrayType>(T)) {
+ uint64_t Count = 1;
+
+ if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
+ Count = CAT->getSize().getZExtValue();
+ }
+ // TODO: how do we handle non constant resource arrays?
+
+ QualType ElemTy = AT->getElementType();
+
+ return AccumulateHLSLResourceSlots(ElemTy, SlotCount, Limit, Ctx,
+ Multiplier * Count);
+ }
+
+ // Case 2: resource leaf
+ if (T->isHLSLResourceRecord()) {
+ llvm::APInt Add(SlotCount.getBitWidth(), Multiplier);
+ SlotCount += Add;
+ return SlotCount.ule(Limit);
+ }
+
+ // Case 3: struct / record
+ if (const auto *RT = dyn_cast<RecordType>(T)) {
+ const RecordDecl *RD = RT->getDecl();
+ for (const FieldDecl *Field : RD->fields()) {
+ if (!AccumulateHLSLResourceSlots(Field->getType(), SlotCount, Limit, Ctx,
+ Multiplier))
+ return false;
+ }
+ return true;
+ }
+
+ // Case 4: everything else
+ return true;
+}
+
+// return true if there is something invalid, false otherwise
+bool ValidateRegisterNumber(StringRef SlotNumStr, Decl *TheDecl,
+ ASTContext &Ctx) {
+ if (ExceedsUInt32Max(SlotNumStr))
+ return true;
----------------
bob80905 wrote:
Fundamentally it's because `StringRef::getAsInteger` does not impose a bit
width.
We want some way to guarantee that the number we're working with is capable of
fitting in 32 bits before working with it.
Consider the case there are 100 9's, or some massive number, and
`consumeInteger` decides to set the bitwidth to 128.
`ugt` comparison between to APInts cannot succeed if they have different bit
widths.
This string comparison conveniently, immediately disqualifies any numbers with
more than 10 digits, accepts numbers with strictly less than 10 digits, and
lexically compares the numbers to disqualify all numbers above 4294967295.
It doesn't bother worrying about parsing the string input into the right
integer data type and having to check if it overflowed or not.
After the integer that is guaranteed to fit in 32 bits is placed into a 64 bit
width data type, then we can proceed with structural type analysis.
https://github.com/llvm/llvm-project/pull/174028
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
