[llvm] Revert "[IR] Add new Range attribute using new ConstantRange Attribute type" (PR #84549)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Mar 8 11:35:46 PST 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-transforms
@llvm/pr-subscribers-llvm-adt
Author: Florian Mayer (fmayer)
<details>
<summary>Changes</summary>
Reverts llvm/llvm-project#<!-- -->83171
broke sanitizer buildbot https://lab.llvm.org/buildbot/#/builders/168/builds/19110/steps/10/logs/stdio
---
Patch is 29.29 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/84549.diff
18 Files Affected:
- (modified) llvm/docs/LangRef.rst (-16)
- (modified) llvm/include/llvm/ADT/FoldingSet.h (-7)
- (modified) llvm/include/llvm/AsmParser/LLParser.h (-1)
- (modified) llvm/include/llvm/Bitcode/LLVMBitCodes.h (-1)
- (modified) llvm/include/llvm/IR/Attributes.h (-23)
- (modified) llvm/include/llvm/IR/Attributes.td (-6)
- (modified) llvm/lib/AsmParser/LLParser.cpp (-43)
- (modified) llvm/lib/Bitcode/Reader/BitcodeReader.cpp (-41)
- (modified) llvm/lib/Bitcode/Writer/BitcodeWriter.cpp (+20-41)
- (modified) llvm/lib/IR/AttributeImpl.h (+1-27)
- (modified) llvm/lib/IR/Attributes.cpp (+2-78)
- (modified) llvm/lib/IR/Verifier.cpp (-5)
- (modified) llvm/lib/Transforms/Utils/CodeExtractor.cpp (-1)
- (removed) llvm/test/Assembler/range-attribute-invalid-range.ll (-6)
- (removed) llvm/test/Assembler/range-attribute-invalid-type.ll (-6)
- (modified) llvm/test/Bitcode/attributes.ll (-10)
- (removed) llvm/test/Verifier/range-attr.ll (-19)
- (modified) llvm/utils/TableGen/Attributes.cpp (+3-6)
``````````diff
diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
index b70220dec92615..a7b77d6f776a7e 100644
--- a/llvm/docs/LangRef.rst
+++ b/llvm/docs/LangRef.rst
@@ -1635,22 +1635,6 @@ Currently, only the following parameter attributes are defined:
This attribute cannot be applied to return values.
-``range(<ty> <a>, <b>)``
- This attribute expresses the possible range of the parameter or return value.
- If the value is not in the specified range, it is converted to poison.
- The arguments passed to ``range`` have the following properties:
-
- - The type must match the scalar type of the parameter or return value.
- - The pair ``a,b`` represents the range ``[a,b)``.
- - Both ``a`` and ``b`` are constants.
- - The range is allowed to wrap.
- - The range should not represent the full or empty set. That is, ``a!=b``.
-
- This attribute may only be applied to parameters or return values with integer
- or vector of integer types.
-
- For vector-typed parameters, the range is applied element-wise.
-
.. _gc:
Garbage Collector Strategy Names
diff --git a/llvm/include/llvm/ADT/FoldingSet.h b/llvm/include/llvm/ADT/FoldingSet.h
index ddc3e52255d6c0..f82eabd5044b22 100644
--- a/llvm/include/llvm/ADT/FoldingSet.h
+++ b/llvm/include/llvm/ADT/FoldingSet.h
@@ -16,7 +16,6 @@
#ifndef LLVM_ADT_FOLDINGSET_H
#define LLVM_ADT_FOLDINGSET_H
-#include "llvm/ADT/APInt.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/STLForwardCompat.h"
#include "llvm/ADT/SmallVector.h"
@@ -355,12 +354,6 @@ class FoldingSetNodeID {
AddInteger(unsigned(I));
AddInteger(unsigned(I >> 32));
}
- void AddInteger(const APInt &Int) {
- const auto *Parts = Int.getRawData();
- for (int i = 0, N = Int.getNumWords(); i < N; ++i) {
- AddInteger(Parts[i]);
- }
- }
void AddBoolean(bool B) { AddInteger(B ? 1U : 0U); }
void AddString(StringRef String);
diff --git a/llvm/include/llvm/AsmParser/LLParser.h b/llvm/include/llvm/AsmParser/LLParser.h
index e85728aa3c0da0..e5e1ade8b38b36 100644
--- a/llvm/include/llvm/AsmParser/LLParser.h
+++ b/llvm/include/llvm/AsmParser/LLParser.h
@@ -369,7 +369,6 @@ namespace llvm {
bool parseFnAttributeValuePairs(AttrBuilder &B,
std::vector<unsigned> &FwdRefAttrGrps,
bool inAttrGrp, LocTy &BuiltinLoc);
- bool parseRangeAttr(AttrBuilder &B);
bool parseRequiredTypeAttr(AttrBuilder &B, lltok::Kind AttrToken,
Attribute::AttrKind AttrKind);
diff --git a/llvm/include/llvm/Bitcode/LLVMBitCodes.h b/llvm/include/llvm/Bitcode/LLVMBitCodes.h
index c0a52d64a101d0..c6f0ddf29a6da8 100644
--- a/llvm/include/llvm/Bitcode/LLVMBitCodes.h
+++ b/llvm/include/llvm/Bitcode/LLVMBitCodes.h
@@ -724,7 +724,6 @@ enum AttributeKindCodes {
ATTR_KIND_WRITABLE = 89,
ATTR_KIND_CORO_ONLY_DESTROY_WHEN_COMPLETE = 90,
ATTR_KIND_DEAD_ON_UNWIND = 91,
- ATTR_KIND_RANGE = 92,
};
enum ComdatSelectionKindCodes {
diff --git a/llvm/include/llvm/IR/Attributes.h b/llvm/include/llvm/IR/Attributes.h
index 0c2a02514ba0e6..a4ebe5d732f568 100644
--- a/llvm/include/llvm/IR/Attributes.h
+++ b/llvm/include/llvm/IR/Attributes.h
@@ -37,7 +37,6 @@ class AttributeMask;
class AttributeImpl;
class AttributeListImpl;
class AttributeSetNode;
-class ConstantRange;
class FoldingSetNodeID;
class Function;
class LLVMContext;
@@ -104,9 +103,6 @@ class Attribute {
static bool isTypeAttrKind(AttrKind Kind) {
return Kind >= FirstTypeAttr && Kind <= LastTypeAttr;
}
- static bool isConstantRangeAttrKind(AttrKind Kind) {
- return Kind >= FirstConstantRangeAttr && Kind <= LastConstantRangeAttr;
- }
static bool canUseAsFnAttr(AttrKind Kind);
static bool canUseAsParamAttr(AttrKind Kind);
@@ -129,8 +125,6 @@ class Attribute {
static Attribute get(LLVMContext &Context, StringRef Kind,
StringRef Val = StringRef());
static Attribute get(LLVMContext &Context, AttrKind Kind, Type *Ty);
- static Attribute get(LLVMContext &Context, AttrKind Kind,
- const ConstantRange &CR);
/// Return a uniquified Attribute object that has the specific
/// alignment set.
@@ -186,9 +180,6 @@ class Attribute {
/// Return true if the attribute is a type attribute.
bool isTypeAttribute() const;
- /// Return true if the attribute is a ConstantRange attribute.
- bool isConstantRangeAttribute() const;
-
/// Return true if the attribute is any kind of attribute.
bool isValid() const { return pImpl; }
@@ -222,10 +213,6 @@ class Attribute {
/// a type attribute.
Type *getValueAsType() const;
- /// Return the attribute's value as a ConstantRange. This requires the
- /// attribute to be a ConstantRange attribute.
- ConstantRange getValueAsConstantRange() const;
-
/// Returns the alignment field of an attribute as a byte alignment
/// value.
MaybeAlign getAlignment() const;
@@ -264,9 +251,6 @@ class Attribute {
/// Return the FPClassTest for nofpclass
FPClassTest getNoFPClass() const;
- /// Returns the value of the range attribute.
- ConstantRange getRange() const;
-
/// The Attribute is converted to a string of equivalent mnemonic. This
/// is, presumably, for writing out the mnemonics for the assembly writer.
std::string getAsString(bool InAttrGrp = false) const;
@@ -1205,13 +1189,6 @@ class AttrBuilder {
// Add nofpclass attribute
AttrBuilder &addNoFPClassAttr(FPClassTest NoFPClassMask);
- /// Add a ConstantRange attribute with the given range.
- AttrBuilder &addConstantRangeAttr(Attribute::AttrKind Kind,
- const ConstantRange &CR);
-
- /// Add range attribute.
- AttrBuilder &addRangeAttr(const ConstantRange &CR);
-
ArrayRef<Attribute> attrs() const { return Attrs; }
bool operator==(const AttrBuilder &B) const;
diff --git a/llvm/include/llvm/IR/Attributes.td b/llvm/include/llvm/IR/Attributes.td
index cef8b17769f0d0..08afecf3201512 100644
--- a/llvm/include/llvm/IR/Attributes.td
+++ b/llvm/include/llvm/IR/Attributes.td
@@ -44,9 +44,6 @@ class StrBoolAttr<string S> : Attr<S, []>;
/// Arbitrary string attribute.
class ComplexStrAttr<string S, list<AttrProperty> P> : Attr<S, P>;
-/// ConstantRange attribute.
-class ConstantRangeAttr<string S, list<AttrProperty> P> : Attr<S, P>;
-
/// Target-independent enum attributes.
/// Alignment of parameter (5 bits) stored as log2 of alignment with +1 bias.
@@ -221,9 +218,6 @@ def OptimizeNone : EnumAttr<"optnone", [FnAttr]>;
/// Similar to byval but without a copy.
def Preallocated : TypeAttr<"preallocated", [FnAttr, ParamAttr]>;
-/// Parameter or return value is within the specified range.
-def Range : ConstantRangeAttr<"range", [ParamAttr, RetAttr]>;
-
/// Function does not access memory.
def ReadNone : EnumAttr<"readnone", [ParamAttr]>;
diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp
index 78bcd94e23fae1..e140c94195205a 100644
--- a/llvm/lib/AsmParser/LLParser.cpp
+++ b/llvm/lib/AsmParser/LLParser.cpp
@@ -1596,8 +1596,6 @@ bool LLParser::parseEnumAttribute(Attribute::AttrKind Attr, AttrBuilder &B,
return true;
}
- case Attribute::Range:
- return parseRangeAttr(B);
default:
B.addAttribute(Attr);
Lex.Lex();
@@ -3010,47 +3008,6 @@ bool LLParser::parseRequiredTypeAttr(AttrBuilder &B, lltok::Kind AttrToken,
return false;
}
-/// parseRangeAttr
-/// ::= range(<ty> <n>,<n>)
-bool LLParser::parseRangeAttr(AttrBuilder &B) {
- Lex.Lex();
-
- APInt Lower;
- APInt Upper;
- Type *Ty = nullptr;
- LocTy TyLoc;
-
- auto ParseAPSInt = [&](unsigned BitWidth, APInt &Val) {
- if (Lex.getKind() != lltok::APSInt)
- return tokError("expected integer");
- if (Lex.getAPSIntVal().getBitWidth() > BitWidth)
- return tokError(
- "integer is too large for the bit width of specified type");
- Val = Lex.getAPSIntVal().extend(BitWidth);
- Lex.Lex();
- return false;
- };
-
- if (parseToken(lltok::lparen, "expected '('") || parseType(Ty, TyLoc))
- return true;
- if (!Ty->isIntegerTy())
- return error(TyLoc, "the range must have integer type!");
-
- unsigned BitWidth = Ty->getPrimitiveSizeInBits();
-
- if (ParseAPSInt(BitWidth, Lower) ||
- parseToken(lltok::comma, "expected ','") || ParseAPSInt(BitWidth, Upper))
- return true;
- if (Lower == Upper)
- return tokError("the range should not represent the full or empty set!");
-
- if (parseToken(lltok::rparen, "expected ')'"))
- return true;
-
- B.addRangeAttr(ConstantRange(Lower, Upper));
- return false;
-}
-
/// parseOptionalOperandBundles
/// ::= /*empty*/
/// ::= '[' OperandBundle [, OperandBundle ]* ']'
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index 9c63116114f3c5..832907a3f53f5f 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -815,30 +815,6 @@ class BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
return getFnValueByID(ValNo, Ty, TyID, ConstExprInsertBB);
}
- Expected<ConstantRange> readConstantRange(ArrayRef<uint64_t> Record,
- unsigned &OpNum) {
- if (Record.size() - OpNum < 3)
- return error("Too few records for range");
- unsigned BitWidth = Record[OpNum++];
- if (BitWidth > 64) {
- unsigned LowerActiveWords = Record[OpNum];
- unsigned UpperActiveWords = Record[OpNum++] >> 32;
- if (Record.size() - OpNum < LowerActiveWords + UpperActiveWords)
- return error("Too few records for range");
- APInt Lower =
- readWideAPInt(ArrayRef(&Record[OpNum], LowerActiveWords), BitWidth);
- OpNum += LowerActiveWords;
- APInt Upper =
- readWideAPInt(ArrayRef(&Record[OpNum], UpperActiveWords), BitWidth);
- OpNum += UpperActiveWords;
- return ConstantRange(Lower, Upper);
- } else {
- int64_t Start = BitcodeReader::decodeSignRotatedValue(Record[OpNum++]);
- int64_t End = BitcodeReader::decodeSignRotatedValue(Record[OpNum++]);
- return ConstantRange(APInt(BitWidth, Start), APInt(BitWidth, End));
- }
- }
-
/// Upgrades old-style typeless byval/sret/inalloca attributes by adding the
/// corresponding argument's pointee type. Also upgrades intrinsics that now
/// require an elementtype attribute.
@@ -2127,8 +2103,6 @@ static Attribute::AttrKind getAttrFromCode(uint64_t Code) {
return Attribute::CoroDestroyOnlyWhenComplete;
case bitc::ATTR_KIND_DEAD_ON_UNWIND:
return Attribute::DeadOnUnwind;
- case bitc::ATTR_KIND_RANGE:
- return Attribute::Range;
}
}
@@ -2298,21 +2272,6 @@ Error BitcodeReader::parseAttributeGroupBlock() {
return error("Not a type attribute");
B.addTypeAttr(Kind, HasType ? getTypeByID(Record[++i]) : nullptr);
- } else if (Record[i] == 7) {
- Attribute::AttrKind Kind;
-
- i++;
- if (Error Err = parseAttrKind(Record[i++], &Kind))
- return Err;
- if (!Attribute::isConstantRangeAttrKind(Kind))
- return error("Not a ConstantRange attribute");
-
- Expected<ConstantRange> MaybeCR = readConstantRange(Record, i);
- if (!MaybeCR)
- return MaybeCR.takeError();
- i--;
-
- B.addConstantRangeAttr(Kind, MaybeCR.get());
} else {
return error("Invalid attribute group entry");
}
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index 597f49332fad25..656f2a6ce870f5 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -844,8 +844,6 @@ static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
return bitc::ATTR_KIND_CORO_ONLY_DESTROY_WHEN_COMPLETE;
case Attribute::DeadOnUnwind:
return bitc::ATTR_KIND_DEAD_ON_UNWIND;
- case Attribute::Range:
- return bitc::ATTR_KIND_RANGE;
case Attribute::EndAttrKinds:
llvm_unreachable("Can not encode end-attribute kinds marker.");
case Attribute::None:
@@ -858,39 +856,6 @@ static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
llvm_unreachable("Trying to encode unknown attribute");
}
-static void emitSignedInt64(SmallVectorImpl<uint64_t> &Vals, uint64_t V) {
- if ((int64_t)V >= 0)
- Vals.push_back(V << 1);
- else
- Vals.push_back((-V << 1) | 1);
-}
-
-static void emitWideAPInt(SmallVectorImpl<uint64_t> &Vals, const APInt &A) {
- // We have an arbitrary precision integer value to write whose
- // bit width is > 64. However, in canonical unsigned integer
- // format it is likely that the high bits are going to be zero.
- // So, we only write the number of active words.
- unsigned NumWords = A.getActiveWords();
- const uint64_t *RawData = A.getRawData();
- for (unsigned i = 0; i < NumWords; i++)
- emitSignedInt64(Vals, RawData[i]);
-}
-
-static void emitConstantRange(SmallVectorImpl<uint64_t> &Record,
- const ConstantRange &CR) {
- unsigned BitWidth = CR.getBitWidth();
- Record.push_back(BitWidth);
- if (BitWidth > 64) {
- Record.push_back(CR.getLower().getActiveWords() |
- (uint64_t(CR.getUpper().getActiveWords()) << 32));
- emitWideAPInt(Record, CR.getLower());
- emitWideAPInt(Record, CR.getUpper());
- } else {
- emitSignedInt64(Record, CR.getLower().getSExtValue());
- emitSignedInt64(Record, CR.getUpper().getSExtValue());
- }
-}
-
void ModuleBitcodeWriter::writeAttributeGroupTable() {
const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =
VE.getAttributeGroups();
@@ -924,17 +889,13 @@ void ModuleBitcodeWriter::writeAttributeGroupTable() {
Record.append(Val.begin(), Val.end());
Record.push_back(0);
}
- } else if (Attr.isTypeAttribute()) {
+ } else {
+ assert(Attr.isTypeAttribute());
Type *Ty = Attr.getValueAsType();
Record.push_back(Ty ? 6 : 5);
Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
if (Ty)
Record.push_back(VE.getTypeID(Attr.getValueAsType()));
- } else {
- assert(Attr.isConstantRangeAttribute());
- Record.push_back(7);
- Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
- emitConstantRange(Record, Attr.getValueAsConstantRange());
}
}
@@ -1755,6 +1716,24 @@ void ModuleBitcodeWriter::writeDIGenericSubrange(
Record.clear();
}
+static void emitSignedInt64(SmallVectorImpl<uint64_t> &Vals, uint64_t V) {
+ if ((int64_t)V >= 0)
+ Vals.push_back(V << 1);
+ else
+ Vals.push_back((-V << 1) | 1);
+}
+
+static void emitWideAPInt(SmallVectorImpl<uint64_t> &Vals, const APInt &A) {
+ // We have an arbitrary precision integer value to write whose
+ // bit width is > 64. However, in canonical unsigned integer
+ // format it is likely that the high bits are going to be zero.
+ // So, we only write the number of active words.
+ unsigned NumWords = A.getActiveWords();
+ const uint64_t *RawData = A.getRawData();
+ for (unsigned i = 0; i < NumWords; i++)
+ emitSignedInt64(Vals, RawData[i]);
+}
+
void ModuleBitcodeWriter::writeDIEnumerator(const DIEnumerator *N,
SmallVectorImpl<uint64_t> &Record,
unsigned Abbrev) {
diff --git a/llvm/lib/IR/AttributeImpl.h b/llvm/lib/IR/AttributeImpl.h
index 9a6427bbc3d557..78496786b0ae95 100644
--- a/llvm/lib/IR/AttributeImpl.h
+++ b/llvm/lib/IR/AttributeImpl.h
@@ -20,7 +20,6 @@
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/Attributes.h"
-#include "llvm/IR/ConstantRange.h"
#include "llvm/Support/TrailingObjects.h"
#include <cassert>
#include <cstddef>
@@ -47,7 +46,6 @@ class AttributeImpl : public FoldingSetNode {
IntAttrEntry,
StringAttrEntry,
TypeAttrEntry,
- ConstantRangeAttrEntry,
};
AttributeImpl(AttrEntryKind KindID) : KindID(KindID) {}
@@ -61,9 +59,6 @@ class AttributeImpl : public FoldingSetNode {
bool isIntAttribute() const { return KindID == IntAttrEntry; }
bool isStringAttribute() const { return KindID == StringAttrEntry; }
bool isTypeAttribute() const { return KindID == TypeAttrEntry; }
- bool isConstantRangeAttribute() const {
- return KindID == ConstantRangeAttrEntry;
- }
bool hasAttribute(Attribute::AttrKind A) const;
bool hasAttribute(StringRef Kind) const;
@@ -77,8 +72,6 @@ class AttributeImpl : public FoldingSetNode {
Type *getValueAsType() const;
- ConstantRange getValueAsConstantRange() const;
-
/// Used when sorting the attributes.
bool operator<(const AttributeImpl &AI) const;
@@ -89,10 +82,8 @@ class AttributeImpl : public FoldingSetNode {
Profile(ID, getKindAsEnum(), getValueAsInt());
else if (isStringAttribute())
Profile(ID, getKindAsString(), getValueAsString());
- else if (isTypeAttribute())
- Profile(ID, getKindAsEnum(), getValueAsType());
else
- Profile(ID, getKindAsEnum(), getValueAsConstantRange());
+ Profile(ID, getKindAsEnum(), getValueAsType());
}
static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind) {
@@ -117,13 +108,6 @@ class AttributeImpl : public FoldingSetNode {
ID.AddInteger(Kind);
ID.AddPointer(Ty);
}
-
- static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind,
- const ConstantRange &CR) {
- ID.AddInteger(Kind);
- ID.AddInteger(CR.getLower());
- ID.AddInteger(CR.getUpper());
- }
};
static_assert(std::is_trivially_destructible<AttributeImpl>::value,
@@ -212,16 +196,6 @@ class TypeAttributeImpl : public EnumAttributeImpl {
Type *getTypeValue() const { return Ty; }
};
-class ConstantRangeAttributeImpl : public EnumAttributeImpl {
- ConstantRange CR;
-
-public:
- ConstantRangeAttributeImpl(Attribute::AttrKind Kind, const ConstantRange &CR)
- : EnumAttributeImpl(ConstantRangeAttrEntry, Kind), CR(CR) {}
-
- ConstantRange getConstantRangeValue() const { return CR; }
-};
-
class AttributeBitSet {
/// Bitset with a bit for each available attribute Attribute::AttrKind.
uint8_t AvailableAttrs[12] = {};
diff --git a/llvm/lib/IR/Attributes.cpp b/llvm/lib/IR/Attributes.cpp
index fec34d0a4a8156..00acbbe7989d8a 100644
--- a/llvm/lib/IR/Attributes.cpp
+++ b/llvm/lib/IR/Attributes.cpp
@@ -24,7 +24,6 @@
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/IR/AttributeMask.h"
-#include "llvm/IR/ConstantRange.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Type.h"
@@ -166,30 +165,6 @@ Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
return Attribute(PA);
}
-Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
- const ConstantRange &CR) {
- assert(Attribute::isConstantRangeAttrKind(Kind) &&
- "Not a ConstantRange attribute");
- LLVMContextImpl *pImpl = Context.pImpl;
- FoldingSetNodeID ID;
- ID.AddInteger(Kind);
- ID.AddInteger(CR.getLower());
- ID.AddInteger(CR.getUpper());
-
- void *InsertPoint;
- AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
-
- if (!PA) {
- // If we didn't find any existing attributes of the same shape then create a
- // new one and insert it.
- PA = new (pImpl->Alloc) ConstantRangeAttributeImpl(Kind, CR);
- pImpl->AttrsSet.InsertNode(PA, InsertPoint);
- }
-
- // Return the Attribute that we found or created.
- return Attribute(PA);
-}
-
Attribute Attribute::getWithAlignment(LLVMContext &Context, Align A) {
assert(A <= llvm::Value::MaximumAlignment && "Alignment too large.");
return get(Context, Alignment, A.value());
@@ -312,14 +287,9 @@ bool Attribute::isTypeAttribute() const {
return pImpl && pImpl->isTypeAttribute();
}
-bool Attribute::isConstantRangeAttribute() const {
- return pImpl && pImpl->isConstantRangeAttribute();
-}
-
Attribute::AttrKind Attribute::getKindAsEnum() const {
if (!pImpl) return None;
- assert((isEnumAttribute() || isIntAttribute() || isTypeAttribute() ||
- isConstantRangeAttribute()) &&
+ assert((isEnumAttribute() || isIntAttribute() || isTypeAttribute()) &&
"Invalid attribute type to get ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/84549
More information about the llvm-commits
mailing list