mirror of
https://github.com/opnsense/src.git
synced 2026-06-04 06:15:33 -04:00
Merge llvm-project release/19.x llvmorg-19.1.0-rc4-0-g0c641568515a
This updates llvm, clang, compiler-rt, libc++, libunwind, lld, lldb and openmp to llvm-project release/19.x llvmorg-19.1.0-rc4-0-g0c641568515a. PR: 280562 MFC after: 1 month
This commit is contained in:
Dimitry Andric
commit
6c4b055cfb
62 changed files with 1392 additions and 1212 deletions
|
|
@ -1805,13 +1805,6 @@ public:
|
|||
QualType DeducedType,
|
||||
bool IsDependent) const;
|
||||
|
||||
private:
|
||||
QualType getDeducedTemplateSpecializationTypeInternal(TemplateName Template,
|
||||
QualType DeducedType,
|
||||
bool IsDependent,
|
||||
QualType Canon) const;
|
||||
|
||||
public:
|
||||
/// Return the unique reference to the type for the specified TagDecl
|
||||
/// (struct/union/class/enum) decl.
|
||||
QualType getTagDeclType(const TagDecl *Decl) const;
|
||||
|
|
|
|||
|
|
@ -347,9 +347,7 @@ public:
|
|||
/// error.
|
||||
void dump() const;
|
||||
|
||||
void Profile(llvm::FoldingSetNodeID &ID) {
|
||||
ID.AddPointer(Storage.getOpaqueValue());
|
||||
}
|
||||
void Profile(llvm::FoldingSetNodeID &ID);
|
||||
|
||||
/// Retrieve the template name as a void pointer.
|
||||
void *getAsVoidPointer() const { return Storage.getOpaqueValue(); }
|
||||
|
|
|
|||
|
|
@ -6421,27 +6421,30 @@ class DeducedTemplateSpecializationType : public DeducedType,
|
|||
|
||||
DeducedTemplateSpecializationType(TemplateName Template,
|
||||
QualType DeducedAsType,
|
||||
bool IsDeducedAsDependent, QualType Canon)
|
||||
bool IsDeducedAsDependent)
|
||||
: DeducedType(DeducedTemplateSpecialization, DeducedAsType,
|
||||
toTypeDependence(Template.getDependence()) |
|
||||
(IsDeducedAsDependent
|
||||
? TypeDependence::DependentInstantiation
|
||||
: TypeDependence::None),
|
||||
Canon),
|
||||
DeducedAsType.isNull() ? QualType(this, 0)
|
||||
: DeducedAsType.getCanonicalType()),
|
||||
Template(Template) {}
|
||||
|
||||
public:
|
||||
/// Retrieve the name of the template that we are deducing.
|
||||
TemplateName getTemplateName() const { return Template;}
|
||||
|
||||
void Profile(llvm::FoldingSetNodeID &ID) const {
|
||||
void Profile(llvm::FoldingSetNodeID &ID) {
|
||||
Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
|
||||
}
|
||||
|
||||
static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
|
||||
QualType Deduced, bool IsDependent) {
|
||||
Template.Profile(ID);
|
||||
Deduced.Profile(ID);
|
||||
QualType CanonicalType =
|
||||
Deduced.isNull() ? Deduced : Deduced.getCanonicalType();
|
||||
ID.AddPointer(CanonicalType.getAsOpaquePtr());
|
||||
ID.AddBoolean(IsDependent || Template.isDependent());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -500,8 +500,8 @@ private:
|
|||
std::vector<SourceRange> NonAffectingRanges;
|
||||
std::vector<SourceLocation::UIntTy> NonAffectingOffsetAdjustments;
|
||||
|
||||
/// A list of classes which need to emit the VTable in the corresponding
|
||||
/// object file.
|
||||
/// A list of classes in named modules which need to emit the VTable in
|
||||
/// the corresponding object file.
|
||||
llvm::SmallVector<CXXRecordDecl *> PendingEmittingVTables;
|
||||
|
||||
/// Computes input files that didn't affect compilation of the current module,
|
||||
|
|
|
|||
|
|
@ -407,6 +407,11 @@ ANALYZER_OPTION(
|
|||
ANALYZER_OPTION(unsigned, MaxSymbolComplexity, "max-symbol-complexity",
|
||||
"The maximum complexity of symbolic constraint.", 35)
|
||||
|
||||
// HACK:https://discourse.llvm.org/t/rfc-make-istainted-and-complex-symbols-friends/79570
|
||||
// Ideally, we should get rid of this option soon.
|
||||
ANALYZER_OPTION(unsigned, MaxTaintedSymbolComplexity, "max-tainted-symbol-complexity",
|
||||
"[DEPRECATED] The maximum complexity of a symbol to carry taint", 9)
|
||||
|
||||
ANALYZER_OPTION(unsigned, MaxTimesInlineLarge, "max-times-inline-large",
|
||||
"The maximum times a large function could be inlined.", 32)
|
||||
|
||||
|
|
|
|||
|
|
@ -6269,9 +6269,11 @@ QualType ASTContext::getUnconstrainedType(QualType T) const {
|
|||
return T;
|
||||
}
|
||||
|
||||
QualType ASTContext::getDeducedTemplateSpecializationTypeInternal(
|
||||
TemplateName Template, QualType DeducedType, bool IsDependent,
|
||||
QualType Canon) const {
|
||||
/// Return the uniqued reference to the deduced template specialization type
|
||||
/// which has been deduced to the given type, or to the canonical undeduced
|
||||
/// such type, or the canonical deduced-but-dependent such type.
|
||||
QualType ASTContext::getDeducedTemplateSpecializationType(
|
||||
TemplateName Template, QualType DeducedType, bool IsDependent) const {
|
||||
// Look in the folding set for an existing type.
|
||||
void *InsertPos = nullptr;
|
||||
llvm::FoldingSetNodeID ID;
|
||||
|
|
@ -6282,8 +6284,7 @@ QualType ASTContext::getDeducedTemplateSpecializationTypeInternal(
|
|||
return QualType(DTST, 0);
|
||||
|
||||
auto *DTST = new (*this, alignof(DeducedTemplateSpecializationType))
|
||||
DeducedTemplateSpecializationType(Template, DeducedType, IsDependent,
|
||||
Canon);
|
||||
DeducedTemplateSpecializationType(Template, DeducedType, IsDependent);
|
||||
llvm::FoldingSetNodeID TempID;
|
||||
DTST->Profile(TempID);
|
||||
assert(ID == TempID && "ID does not match");
|
||||
|
|
@ -6292,20 +6293,6 @@ QualType ASTContext::getDeducedTemplateSpecializationTypeInternal(
|
|||
return QualType(DTST, 0);
|
||||
}
|
||||
|
||||
/// Return the uniqued reference to the deduced template specialization type
|
||||
/// which has been deduced to the given type, or to the canonical undeduced
|
||||
/// such type, or the canonical deduced-but-dependent such type.
|
||||
QualType ASTContext::getDeducedTemplateSpecializationType(
|
||||
TemplateName Template, QualType DeducedType, bool IsDependent) const {
|
||||
QualType Canon = DeducedType.isNull()
|
||||
? getDeducedTemplateSpecializationTypeInternal(
|
||||
getCanonicalTemplateName(Template), QualType(),
|
||||
IsDependent, QualType())
|
||||
: DeducedType.getCanonicalType();
|
||||
return getDeducedTemplateSpecializationTypeInternal(Template, DeducedType,
|
||||
IsDependent, Canon);
|
||||
}
|
||||
|
||||
/// getAtomicType - Return the uniqued reference to the atomic type for
|
||||
/// the given value type.
|
||||
QualType ASTContext::getAtomicType(QualType T) const {
|
||||
|
|
|
|||
|
|
@ -264,6 +264,15 @@ bool TemplateName::containsUnexpandedParameterPack() const {
|
|||
return getDependence() & TemplateNameDependence::UnexpandedPack;
|
||||
}
|
||||
|
||||
void TemplateName::Profile(llvm::FoldingSetNodeID &ID) {
|
||||
if (const auto* USD = getAsUsingShadowDecl())
|
||||
ID.AddPointer(USD->getCanonicalDecl());
|
||||
else if (const auto *TD = getAsTemplateDecl())
|
||||
ID.AddPointer(TD->getCanonicalDecl());
|
||||
else
|
||||
ID.AddPointer(Storage.getOpaqueValue());
|
||||
}
|
||||
|
||||
void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
|
||||
Qualified Qual) const {
|
||||
auto handleAnonymousTTP = [](TemplateDecl *TD, raw_ostream &OS) {
|
||||
|
|
|
|||
|
|
@ -471,23 +471,25 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
|
|||
if (HasSVE2 && HasSVE2SM4)
|
||||
Builder.defineMacro("__ARM_FEATURE_SVE2_SM4", "1");
|
||||
|
||||
if (HasSVEB16B16)
|
||||
Builder.defineMacro("__ARM_FEATURE_SVE_B16B16", "1");
|
||||
|
||||
if (HasSME) {
|
||||
Builder.defineMacro("__ARM_FEATURE_SME");
|
||||
Builder.defineMacro("__ARM_FEATURE_LOCALLY_STREAMING", "1");
|
||||
}
|
||||
|
||||
if (HasSME2) {
|
||||
Builder.defineMacro("__ARM_FEATURE_SME", "1");
|
||||
if (HasSME2)
|
||||
Builder.defineMacro("__ARM_FEATURE_SME2", "1");
|
||||
Builder.defineMacro("__ARM_FEATURE_LOCALLY_STREAMING", "1");
|
||||
}
|
||||
|
||||
if (HasSME2p1) {
|
||||
Builder.defineMacro("__ARM_FEATURE_SME", "1");
|
||||
Builder.defineMacro("__ARM_FEATURE_SME2", "1");
|
||||
if (HasSME2p1)
|
||||
Builder.defineMacro("__ARM_FEATURE_SME2p1", "1");
|
||||
Builder.defineMacro("__ARM_FEATURE_LOCALLY_STREAMING", "1");
|
||||
}
|
||||
|
||||
if (HasSMEF16F16)
|
||||
Builder.defineMacro("__ARM_FEATURE_SME_F16F16", "1");
|
||||
|
||||
if (HasSMEB16B16)
|
||||
Builder.defineMacro("__ARM_FEATURE_SME_B16B16", "1");
|
||||
|
||||
if (HasCRC)
|
||||
Builder.defineMacro("__ARM_FEATURE_CRC32", "1");
|
||||
|
|
@ -749,6 +751,7 @@ bool AArch64TargetInfo::hasFeature(StringRef Feature) const {
|
|||
.Case("sve", FPU & SveMode)
|
||||
.Case("sve-bf16", FPU & SveMode && HasBFloat16)
|
||||
.Case("sve-i8mm", FPU & SveMode && HasMatMul)
|
||||
.Case("sve-b16b16", HasSVEB16B16)
|
||||
.Case("f32mm", FPU & SveMode && HasMatmulFP32)
|
||||
.Case("f64mm", FPU & SveMode && HasMatmulFP64)
|
||||
.Case("sve2", FPU & SveMode && HasSVE2)
|
||||
|
|
@ -763,6 +766,8 @@ bool AArch64TargetInfo::hasFeature(StringRef Feature) const {
|
|||
.Case("sme-f64f64", HasSMEF64F64)
|
||||
.Case("sme-i16i64", HasSMEI16I64)
|
||||
.Case("sme-fa64", HasSMEFA64)
|
||||
.Case("sme-f16f16", HasSMEF16F16)
|
||||
.Case("sme-b16b16", HasSMEB16B16)
|
||||
.Cases("memtag", "memtag2", HasMTE)
|
||||
.Case("sb", HasSB)
|
||||
.Case("predres", HasPredRes)
|
||||
|
|
@ -863,6 +868,8 @@ bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
|
|||
HasSVE2 = true;
|
||||
HasSVE2SM4 = true;
|
||||
}
|
||||
if (Feature == "+sve-b16b16")
|
||||
HasSVEB16B16 = true;
|
||||
if (Feature == "+sve2-bitperm") {
|
||||
FPU |= NeonMode;
|
||||
FPU |= SveMode;
|
||||
|
|
@ -919,6 +926,21 @@ bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
|
|||
HasSVE2 = true;
|
||||
HasSMEFA64 = true;
|
||||
}
|
||||
if (Feature == "+sme-f16f16") {
|
||||
HasSME = true;
|
||||
HasSME2 = true;
|
||||
HasBFloat16 = true;
|
||||
HasFullFP16 = true;
|
||||
HasSMEF16F16 = true;
|
||||
}
|
||||
if (Feature == "+sme-b16b16") {
|
||||
HasSME = true;
|
||||
HasSME2 = true;
|
||||
HasBFloat16 = true;
|
||||
HasFullFP16 = true;
|
||||
HasSVEB16B16 = true;
|
||||
HasSMEB16B16 = true;
|
||||
}
|
||||
if (Feature == "+sb")
|
||||
HasSB = true;
|
||||
if (Feature == "+predres")
|
||||
|
|
|
|||
|
|
@ -53,6 +53,7 @@ class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo {
|
|||
bool HasSVE2AES = false;
|
||||
bool HasSVE2SHA3 = false;
|
||||
bool HasSVE2SM4 = false;
|
||||
bool HasSVEB16B16 = false;
|
||||
bool HasSVE2BitPerm = false;
|
||||
bool HasMatmulFP64 = false;
|
||||
bool HasMatmulFP32 = false;
|
||||
|
|
@ -71,6 +72,8 @@ class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo {
|
|||
bool HasSME2 = false;
|
||||
bool HasSMEF64F64 = false;
|
||||
bool HasSMEI16I64 = false;
|
||||
bool HasSMEF16F16 = false;
|
||||
bool HasSMEB16B16 = false;
|
||||
bool HasSME2p1 = false;
|
||||
bool HasSB = false;
|
||||
bool HasPredRes = false;
|
||||
|
|
|
|||
|
|
@ -2953,7 +2953,15 @@ static bool sdkSupportsBuiltinModules(
|
|||
case Darwin::MacOS:
|
||||
return SDKVersion >= VersionTuple(15U);
|
||||
case Darwin::IPhoneOS:
|
||||
return SDKVersion >= VersionTuple(18U);
|
||||
switch (TargetEnvironment) {
|
||||
case Darwin::MacCatalyst:
|
||||
// Mac Catalyst uses `-target arm64-apple-ios18.0-macabi` so the platform
|
||||
// is iOS, but it builds with the macOS SDK, so it's the macOS SDK version
|
||||
// that's relevant.
|
||||
return SDKVersion >= VersionTuple(15U);
|
||||
default:
|
||||
return SDKVersion >= VersionTuple(18U);
|
||||
}
|
||||
case Darwin::TvOS:
|
||||
return SDKVersion >= VersionTuple(18U);
|
||||
case Darwin::WatchOS:
|
||||
|
|
|
|||
|
|
@ -842,10 +842,8 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
|
|||
CurrentState.ContainsUnwrappedBuilder = true;
|
||||
}
|
||||
|
||||
if (Current.is(TT_TrailingReturnArrow) &&
|
||||
Style.Language == FormatStyle::LK_Java) {
|
||||
if (Current.is(TT_LambdaArrow) && Style.Language == FormatStyle::LK_Java)
|
||||
CurrentState.NoLineBreak = true;
|
||||
}
|
||||
if (Current.isMemberAccess() && Previous.is(tok::r_paren) &&
|
||||
(Previous.MatchingParen &&
|
||||
(Previous.TotalLength - Previous.MatchingParen->TotalLength > 10))) {
|
||||
|
|
@ -1000,7 +998,7 @@ unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
|
|||
//
|
||||
// is common and should be formatted like a free-standing function. The same
|
||||
// goes for wrapping before the lambda return type arrow.
|
||||
if (Current.isNot(TT_TrailingReturnArrow) &&
|
||||
if (Current.isNot(TT_LambdaArrow) &&
|
||||
(!Style.isJavaScript() || Current.NestingLevel != 0 ||
|
||||
!PreviousNonComment || PreviousNonComment->isNot(tok::equal) ||
|
||||
!Current.isOneOf(Keywords.kw_async, Keywords.kw_function))) {
|
||||
|
|
@ -1257,7 +1255,7 @@ unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
|
|||
}
|
||||
return CurrentState.Indent;
|
||||
}
|
||||
if (Current.is(TT_TrailingReturnArrow) &&
|
||||
if (Current.is(TT_LambdaArrow) &&
|
||||
Previous.isOneOf(tok::kw_noexcept, tok::kw_mutable, tok::kw_constexpr,
|
||||
tok::kw_consteval, tok::kw_static, TT_AttributeSquare)) {
|
||||
return ContinuationIndent;
|
||||
|
|
@ -1590,7 +1588,7 @@ unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
|
|||
}
|
||||
if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)
|
||||
CurrentState.NestedBlockIndent = State.Column + Current.ColumnWidth + 1;
|
||||
if (Current.isOneOf(TT_LambdaLSquare, TT_TrailingReturnArrow))
|
||||
if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow))
|
||||
CurrentState.LastSpace = State.Column;
|
||||
if (Current.is(TT_RequiresExpression) &&
|
||||
Style.RequiresExpressionIndentation == FormatStyle::REI_Keyword) {
|
||||
|
|
|
|||
|
|
@ -102,6 +102,7 @@ namespace format {
|
|||
TYPE(JsTypeColon) \
|
||||
TYPE(JsTypeOperator) \
|
||||
TYPE(JsTypeOptionalQuestion) \
|
||||
TYPE(LambdaArrow) \
|
||||
TYPE(LambdaLBrace) \
|
||||
TYPE(LambdaLSquare) \
|
||||
TYPE(LeadingJavaAnnotation) \
|
||||
|
|
@ -725,7 +726,7 @@ public:
|
|||
bool isMemberAccess() const {
|
||||
return isOneOf(tok::arrow, tok::period, tok::arrowstar) &&
|
||||
!isOneOf(TT_DesignatedInitializerPeriod, TT_TrailingReturnArrow,
|
||||
TT_LeadingJavaAnnotation);
|
||||
TT_LambdaArrow, TT_LeadingJavaAnnotation);
|
||||
}
|
||||
|
||||
bool isPointerOrReference() const {
|
||||
|
|
|
|||
|
|
@ -249,7 +249,7 @@ private:
|
|||
if (Precedence > prec::Conditional && Precedence < prec::Relational)
|
||||
return false;
|
||||
}
|
||||
if (Prev.is(TT_ConditionalExpr))
|
||||
if (Prev.isOneOf(tok::question, tok::colon) && !Style.isProto())
|
||||
SeenTernaryOperator = true;
|
||||
updateParameterCount(Left, CurrentToken);
|
||||
if (Style.Language == FormatStyle::LK_Proto) {
|
||||
|
|
@ -831,7 +831,7 @@ private:
|
|||
}
|
||||
// An arrow after an ObjC method expression is not a lambda arrow.
|
||||
if (CurrentToken->is(TT_ObjCMethodExpr) && CurrentToken->Next &&
|
||||
CurrentToken->Next->is(TT_TrailingReturnArrow)) {
|
||||
CurrentToken->Next->is(TT_LambdaArrow)) {
|
||||
CurrentToken->Next->overwriteFixedType(TT_Unknown);
|
||||
}
|
||||
Left->MatchingParen = CurrentToken;
|
||||
|
|
@ -1769,8 +1769,10 @@ private:
|
|||
}
|
||||
break;
|
||||
case tok::arrow:
|
||||
if (Tok->Previous && Tok->Previous->is(tok::kw_noexcept))
|
||||
if (Tok->isNot(TT_LambdaArrow) && Tok->Previous &&
|
||||
Tok->Previous->is(tok::kw_noexcept)) {
|
||||
Tok->setType(TT_TrailingReturnArrow);
|
||||
}
|
||||
break;
|
||||
case tok::equal:
|
||||
// In TableGen, there must be a value after "=";
|
||||
|
|
@ -2056,11 +2058,11 @@ private:
|
|||
TT_LambdaLSquare, TT_LambdaLBrace, TT_AttributeMacro, TT_IfMacro,
|
||||
TT_ForEachMacro, TT_TypenameMacro, TT_FunctionLBrace,
|
||||
TT_ImplicitStringLiteral, TT_InlineASMBrace, TT_FatArrow,
|
||||
TT_NamespaceMacro, TT_OverloadedOperator, TT_RegexLiteral,
|
||||
TT_TemplateString, TT_ObjCStringLiteral, TT_UntouchableMacroFunc,
|
||||
TT_StatementAttributeLikeMacro, TT_FunctionLikeOrFreestandingMacro,
|
||||
TT_ClassLBrace, TT_EnumLBrace, TT_RecordLBrace, TT_StructLBrace,
|
||||
TT_UnionLBrace, TT_RequiresClause,
|
||||
TT_LambdaArrow, TT_NamespaceMacro, TT_OverloadedOperator,
|
||||
TT_RegexLiteral, TT_TemplateString, TT_ObjCStringLiteral,
|
||||
TT_UntouchableMacroFunc, TT_StatementAttributeLikeMacro,
|
||||
TT_FunctionLikeOrFreestandingMacro, TT_ClassLBrace, TT_EnumLBrace,
|
||||
TT_RecordLBrace, TT_StructLBrace, TT_UnionLBrace, TT_RequiresClause,
|
||||
TT_RequiresClauseInARequiresExpression, TT_RequiresExpression,
|
||||
TT_RequiresExpressionLParen, TT_RequiresExpressionLBrace,
|
||||
TT_BracedListLBrace)) {
|
||||
|
|
@ -2246,7 +2248,7 @@ private:
|
|||
Contexts.back().IsExpression = true;
|
||||
} else if (Current.is(TT_TrailingReturnArrow)) {
|
||||
Contexts.back().IsExpression = false;
|
||||
} else if (Current.is(Keywords.kw_assert)) {
|
||||
} else if (Current.isOneOf(TT_LambdaArrow, Keywords.kw_assert)) {
|
||||
Contexts.back().IsExpression = Style.Language == FormatStyle::LK_Java;
|
||||
} else if (Current.Previous &&
|
||||
Current.Previous->is(TT_CtorInitializerColon)) {
|
||||
|
|
@ -2381,7 +2383,7 @@ private:
|
|||
AutoFound = true;
|
||||
} else if (Current.is(tok::arrow) &&
|
||||
Style.Language == FormatStyle::LK_Java) {
|
||||
Current.setType(TT_TrailingReturnArrow);
|
||||
Current.setType(TT_LambdaArrow);
|
||||
} else if (Current.is(tok::arrow) && Style.isVerilog()) {
|
||||
// The implication operator.
|
||||
Current.setType(TT_BinaryOperator);
|
||||
|
|
@ -2874,6 +2876,8 @@ private:
|
|||
// Search for unexpected tokens.
|
||||
for (auto *Prev = BeforeRParen; Prev != LParen; Prev = Prev->Previous) {
|
||||
if (Prev->is(tok::r_paren)) {
|
||||
if (Prev->is(TT_CastRParen))
|
||||
return false;
|
||||
Prev = Prev->MatchingParen;
|
||||
if (!Prev)
|
||||
return false;
|
||||
|
|
@ -3276,7 +3280,7 @@ private:
|
|||
}
|
||||
if (Current->is(TT_JsComputedPropertyName))
|
||||
return prec::Assignment;
|
||||
if (Current->is(TT_TrailingReturnArrow))
|
||||
if (Current->is(TT_LambdaArrow))
|
||||
return prec::Comma;
|
||||
if (Current->is(TT_FatArrow))
|
||||
return prec::Assignment;
|
||||
|
|
@ -4200,7 +4204,7 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line,
|
|||
}
|
||||
if (Right.is(TT_PointerOrReference))
|
||||
return 190;
|
||||
if (Right.is(TT_TrailingReturnArrow))
|
||||
if (Right.is(TT_LambdaArrow))
|
||||
return 110;
|
||||
if (Left.is(tok::equal) && Right.is(tok::l_brace))
|
||||
return 160;
|
||||
|
|
@ -4467,10 +4471,8 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
|
|||
}
|
||||
if (Left.is(tok::colon))
|
||||
return Left.isNot(TT_ObjCMethodExpr);
|
||||
if (Left.is(tok::coloncolon)) {
|
||||
return Right.is(tok::star) && Right.is(TT_PointerOrReference) &&
|
||||
Style.PointerAlignment != FormatStyle::PAS_Left;
|
||||
}
|
||||
if (Left.is(tok::coloncolon))
|
||||
return false;
|
||||
if (Left.is(tok::less) || Right.isOneOf(tok::greater, tok::less)) {
|
||||
if (Style.Language == FormatStyle::LK_TextProto ||
|
||||
(Style.Language == FormatStyle::LK_Proto &&
|
||||
|
|
@ -4580,8 +4582,14 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
|
|||
if (!BeforeLeft)
|
||||
return false;
|
||||
if (BeforeLeft->is(tok::coloncolon)) {
|
||||
return Left.is(tok::star) &&
|
||||
Style.PointerAlignment != FormatStyle::PAS_Right;
|
||||
if (Left.isNot(tok::star))
|
||||
return false;
|
||||
assert(Style.PointerAlignment != FormatStyle::PAS_Right);
|
||||
if (!Right.startsSequence(tok::identifier, tok::r_paren))
|
||||
return true;
|
||||
assert(Right.Next);
|
||||
const auto *LParen = Right.Next->MatchingParen;
|
||||
return !LParen || LParen->isNot(TT_FunctionTypeLParen);
|
||||
}
|
||||
return !BeforeLeft->isOneOf(tok::l_paren, tok::l_square);
|
||||
}
|
||||
|
|
@ -5274,9 +5282,10 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line,
|
|||
return false;
|
||||
}
|
||||
|
||||
if (Right.is(TT_TrailingReturnArrow) || Left.is(TT_TrailingReturnArrow))
|
||||
if (Right.isOneOf(TT_TrailingReturnArrow, TT_LambdaArrow) ||
|
||||
Left.isOneOf(TT_TrailingReturnArrow, TT_LambdaArrow)) {
|
||||
return true;
|
||||
|
||||
}
|
||||
if (Left.is(tok::comma) && Right.isNot(TT_OverloadedOperatorLParen) &&
|
||||
// In an unexpanded macro call we only find the parentheses and commas
|
||||
// in a line; the commas and closing parenthesis do not require a space.
|
||||
|
|
@ -6294,8 +6303,8 @@ bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
|
|||
return Left.isOneOf(tok::comma, tok::coloncolon, tok::semi, tok::l_brace,
|
||||
tok::kw_class, tok::kw_struct, tok::comment) ||
|
||||
Right.isMemberAccess() ||
|
||||
Right.isOneOf(TT_TrailingReturnArrow, tok::lessless, tok::colon,
|
||||
tok::l_square, tok::at) ||
|
||||
Right.isOneOf(TT_TrailingReturnArrow, TT_LambdaArrow, tok::lessless,
|
||||
tok::colon, tok::l_square, tok::at) ||
|
||||
(Left.is(tok::r_paren) &&
|
||||
Right.isOneOf(tok::identifier, tok::kw_const)) ||
|
||||
(Left.is(tok::l_paren) && Right.isNot(tok::r_paren)) ||
|
||||
|
|
|
|||
|
|
@ -609,9 +609,8 @@ void UnwrappedLineParser::calculateBraceTypes(bool ExpectClassBody) {
|
|||
ProbablyBracedList = NextTok->isNot(tok::l_square);
|
||||
}
|
||||
|
||||
// Cpp macro definition body that is a nonempty braced list or block:
|
||||
// Cpp macro definition body containing nonempty braced list or block:
|
||||
if (IsCpp && Line->InMacroBody && PrevTok != FormatTok &&
|
||||
!FormatTok->Previous && NextTok->is(tok::eof) &&
|
||||
// A statement can end with only `;` (simple statement), a block
|
||||
// closing brace (compound statement), or `:` (label statement).
|
||||
// If PrevTok is a block opening brace, Tok ends an empty block.
|
||||
|
|
@ -2322,7 +2321,7 @@ bool UnwrappedLineParser::tryToParseLambda() {
|
|||
// This might or might not actually be a lambda arrow (this could be an
|
||||
// ObjC method invocation followed by a dereferencing arrow). We might
|
||||
// reset this back to TT_Unknown in TokenAnnotator.
|
||||
FormatTok->setFinalizedType(TT_TrailingReturnArrow);
|
||||
FormatTok->setFinalizedType(TT_LambdaArrow);
|
||||
SeenArrow = true;
|
||||
nextToken();
|
||||
break;
|
||||
|
|
@ -2668,6 +2667,7 @@ void UnwrappedLineParser::parseSquare(bool LambdaIntroducer) {
|
|||
break;
|
||||
}
|
||||
case tok::at:
|
||||
case tok::colon:
|
||||
nextToken();
|
||||
if (FormatTok->is(tok::l_brace)) {
|
||||
nextToken();
|
||||
|
|
@ -3978,6 +3978,9 @@ void UnwrappedLineParser::parseRecord(bool ParseAsExpr) {
|
|||
auto IsNonMacroIdentifier = [](const FormatToken *Tok) {
|
||||
return Tok->is(tok::identifier) && Tok->TokenText != Tok->TokenText.upper();
|
||||
};
|
||||
// JavaScript/TypeScript supports anonymous classes like:
|
||||
// a = class extends foo { }
|
||||
bool JSPastExtendsOrImplements = false;
|
||||
// The actual identifier can be a nested name specifier, and in macros
|
||||
// it is often token-pasted.
|
||||
// An [[attribute]] can be before the identifier.
|
||||
|
|
@ -3988,6 +3991,7 @@ void UnwrappedLineParser::parseRecord(bool ParseAsExpr) {
|
|||
FormatTok->isOneOf(tok::period, tok::comma))) {
|
||||
if (Style.isJavaScript() &&
|
||||
FormatTok->isOneOf(Keywords.kw_extends, Keywords.kw_implements)) {
|
||||
JSPastExtendsOrImplements = true;
|
||||
// JavaScript/TypeScript supports inline object types in
|
||||
// extends/implements positions:
|
||||
// class Foo implements {bar: number} { }
|
||||
|
|
@ -4011,10 +4015,11 @@ void UnwrappedLineParser::parseRecord(bool ParseAsExpr) {
|
|||
}
|
||||
break;
|
||||
case tok::coloncolon:
|
||||
case tok::hashhash:
|
||||
break;
|
||||
default:
|
||||
if (!ClassName && Previous->is(tok::identifier) &&
|
||||
Previous->isNot(TT_AttributeMacro)) {
|
||||
if (!JSPastExtendsOrImplements && !ClassName &&
|
||||
Previous->is(tok::identifier) && Previous->isNot(TT_AttributeMacro)) {
|
||||
ClassName = Previous;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -469,7 +469,9 @@ AlignTokenSequence(const FormatStyle &Style, unsigned Start, unsigned End,
|
|||
// except if the token is equal, then a space is needed.
|
||||
if ((Style.PointerAlignment == FormatStyle::PAS_Right ||
|
||||
Style.ReferenceAlignment == FormatStyle::RAS_Right) &&
|
||||
CurrentChange.Spaces != 0 && CurrentChange.Tok->isNot(tok::equal)) {
|
||||
CurrentChange.Spaces != 0 &&
|
||||
!CurrentChange.Tok->isOneOf(tok::equal, tok::r_paren,
|
||||
TT_TemplateCloser)) {
|
||||
const bool ReferenceNotRightAligned =
|
||||
Style.ReferenceAlignment != FormatStyle::RAS_Right &&
|
||||
Style.ReferenceAlignment != FormatStyle::RAS_Pointer;
|
||||
|
|
|
|||
|
|
@ -1771,7 +1771,7 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_undefined_pd(void) {
|
|||
/// lower 64 bits contain the value of the parameter. The upper 64 bits are
|
||||
/// set to zero.
|
||||
static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_set_sd(double __w) {
|
||||
return __extension__(__m128d){__w, 0};
|
||||
return __extension__(__m128d){__w, 0.0};
|
||||
}
|
||||
|
||||
/// Constructs a 128-bit floating-point vector of [2 x double], with each
|
||||
|
|
|
|||
|
|
@ -1910,7 +1910,7 @@ _mm_undefined_ps(void)
|
|||
static __inline__ __m128 __DEFAULT_FN_ATTRS
|
||||
_mm_set_ss(float __w)
|
||||
{
|
||||
return __extension__ (__m128){ __w, 0, 0, 0 };
|
||||
return __extension__ (__m128){ __w, 0.0f, 0.0f, 0.0f };
|
||||
}
|
||||
|
||||
/// Constructs a 128-bit floating-point vector of [4 x float], with each
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@
|
|||
#include "clang/AST/Expr.h"
|
||||
#include "clang/AST/ExprConcepts.h"
|
||||
#include "clang/AST/PrettyDeclStackTrace.h"
|
||||
#include "clang/AST/RecursiveASTVisitor.h"
|
||||
#include "clang/AST/Type.h"
|
||||
#include "clang/AST/TypeLoc.h"
|
||||
#include "clang/AST/TypeVisitor.h"
|
||||
|
|
@ -87,12 +88,19 @@ struct Response {
|
|||
// than lambda classes.
|
||||
const FunctionDecl *
|
||||
getPrimaryTemplateOfGenericLambda(const FunctionDecl *LambdaCallOperator) {
|
||||
if (!isLambdaCallOperator(LambdaCallOperator))
|
||||
return LambdaCallOperator;
|
||||
while (true) {
|
||||
if (auto *FTD = dyn_cast_if_present<FunctionTemplateDecl>(
|
||||
LambdaCallOperator->getDescribedTemplate());
|
||||
FTD && FTD->getInstantiatedFromMemberTemplate()) {
|
||||
LambdaCallOperator =
|
||||
FTD->getInstantiatedFromMemberTemplate()->getTemplatedDecl();
|
||||
} else if (LambdaCallOperator->getPrimaryTemplate()) {
|
||||
// Cases where the lambda operator is instantiated in
|
||||
// TemplateDeclInstantiator::VisitCXXMethodDecl.
|
||||
LambdaCallOperator =
|
||||
LambdaCallOperator->getPrimaryTemplate()->getTemplatedDecl();
|
||||
} else if (auto *Prev = cast<CXXMethodDecl>(LambdaCallOperator)
|
||||
->getInstantiatedFromMemberFunction())
|
||||
LambdaCallOperator = Prev;
|
||||
|
|
@ -138,22 +146,28 @@ getEnclosingTypeAliasTemplateDecl(Sema &SemaRef) {
|
|||
// Check if we are currently inside of a lambda expression that is
|
||||
// surrounded by a using alias declaration. e.g.
|
||||
// template <class> using type = decltype([](auto) { ^ }());
|
||||
// By checking if:
|
||||
// 1. The lambda expression and the using alias declaration share the
|
||||
// same declaration context.
|
||||
// 2. They have the same template depth.
|
||||
// We have to do so since a TypeAliasTemplateDecl (or a TypeAliasDecl) is never
|
||||
// a DeclContext, nor does it have an associated specialization Decl from which
|
||||
// we could collect these template arguments.
|
||||
bool isLambdaEnclosedByTypeAliasDecl(
|
||||
const FunctionDecl *PrimaryLambdaCallOperator,
|
||||
const FunctionDecl *LambdaCallOperator,
|
||||
const TypeAliasTemplateDecl *PrimaryTypeAliasDecl) {
|
||||
return cast<CXXRecordDecl>(PrimaryLambdaCallOperator->getDeclContext())
|
||||
->getTemplateDepth() ==
|
||||
PrimaryTypeAliasDecl->getTemplateDepth() &&
|
||||
getLambdaAwareParentOfDeclContext(
|
||||
const_cast<FunctionDecl *>(PrimaryLambdaCallOperator)) ==
|
||||
PrimaryTypeAliasDecl->getDeclContext();
|
||||
struct Visitor : RecursiveASTVisitor<Visitor> {
|
||||
Visitor(const FunctionDecl *CallOperator) : CallOperator(CallOperator) {}
|
||||
bool VisitLambdaExpr(const LambdaExpr *LE) {
|
||||
// Return true to bail out of the traversal, implying the Decl contains
|
||||
// the lambda.
|
||||
return getPrimaryTemplateOfGenericLambda(LE->getCallOperator()) !=
|
||||
CallOperator;
|
||||
}
|
||||
const FunctionDecl *CallOperator;
|
||||
};
|
||||
|
||||
QualType Underlying =
|
||||
PrimaryTypeAliasDecl->getTemplatedDecl()->getUnderlyingType();
|
||||
|
||||
return !Visitor(getPrimaryTemplateOfGenericLambda(LambdaCallOperator))
|
||||
.TraverseType(Underlying);
|
||||
}
|
||||
|
||||
// Add template arguments from a variable template instantiation.
|
||||
|
|
@ -290,23 +304,8 @@ Response HandleFunction(Sema &SemaRef, const FunctionDecl *Function,
|
|||
|
||||
// If this function is a generic lambda specialization, we are done.
|
||||
if (!ForConstraintInstantiation &&
|
||||
isGenericLambdaCallOperatorOrStaticInvokerSpecialization(Function)) {
|
||||
// TypeAliasTemplateDecls should be taken into account, e.g.
|
||||
// when we're deducing the return type of a lambda.
|
||||
//
|
||||
// template <class> int Value = 0;
|
||||
// template <class T>
|
||||
// using T = decltype([]<int U = 0>() { return Value<T>; }());
|
||||
//
|
||||
if (auto TypeAlias = getEnclosingTypeAliasTemplateDecl(SemaRef)) {
|
||||
if (isLambdaEnclosedByTypeAliasDecl(
|
||||
/*PrimaryLambdaCallOperator=*/getPrimaryTemplateOfGenericLambda(
|
||||
Function),
|
||||
/*PrimaryTypeAliasDecl=*/TypeAlias.PrimaryTypeAliasDecl))
|
||||
return Response::UseNextDecl(Function);
|
||||
}
|
||||
isGenericLambdaCallOperatorOrStaticInvokerSpecialization(Function))
|
||||
return Response::Done();
|
||||
}
|
||||
|
||||
} else if (Function->getDescribedFunctionTemplate()) {
|
||||
assert(
|
||||
|
|
@ -418,10 +417,9 @@ Response HandleRecordDecl(Sema &SemaRef, const CXXRecordDecl *Rec,
|
|||
// Retrieve the template arguments for a using alias declaration.
|
||||
// This is necessary for constraint checking, since we always keep
|
||||
// constraints relative to the primary template.
|
||||
if (auto TypeAlias = getEnclosingTypeAliasTemplateDecl(SemaRef)) {
|
||||
const FunctionDecl *PrimaryLambdaCallOperator =
|
||||
getPrimaryTemplateOfGenericLambda(Rec->getLambdaCallOperator());
|
||||
if (isLambdaEnclosedByTypeAliasDecl(PrimaryLambdaCallOperator,
|
||||
if (auto TypeAlias = getEnclosingTypeAliasTemplateDecl(SemaRef);
|
||||
ForConstraintInstantiation && TypeAlias) {
|
||||
if (isLambdaEnclosedByTypeAliasDecl(Rec->getLambdaCallOperator(),
|
||||
TypeAlias.PrimaryTypeAliasDecl)) {
|
||||
Result.addOuterTemplateArguments(TypeAlias.Template,
|
||||
TypeAlias.AssociatedTemplateArguments,
|
||||
|
|
@ -1642,12 +1640,17 @@ namespace {
|
|||
|
||||
CXXRecordDecl::LambdaDependencyKind
|
||||
ComputeLambdaDependency(LambdaScopeInfo *LSI) {
|
||||
auto &CCS = SemaRef.CodeSynthesisContexts.back();
|
||||
if (CCS.Kind ==
|
||||
Sema::CodeSynthesisContext::TypeAliasTemplateInstantiation) {
|
||||
unsigned TypeAliasDeclDepth = CCS.Entity->getTemplateDepth();
|
||||
if (auto TypeAlias =
|
||||
TemplateInstArgsHelpers::getEnclosingTypeAliasTemplateDecl(
|
||||
getSema());
|
||||
TypeAlias && TemplateInstArgsHelpers::isLambdaEnclosedByTypeAliasDecl(
|
||||
LSI->CallOperator, TypeAlias.PrimaryTypeAliasDecl)) {
|
||||
unsigned TypeAliasDeclDepth = TypeAlias.Template->getTemplateDepth();
|
||||
if (TypeAliasDeclDepth >= TemplateArgs.getNumSubstitutedLevels())
|
||||
return CXXRecordDecl::LambdaDependencyKind::LDK_AlwaysDependent;
|
||||
for (const TemplateArgument &TA : TypeAlias.AssociatedTemplateArguments)
|
||||
if (TA.isDependent())
|
||||
return CXXRecordDecl::LambdaDependencyKind::LDK_AlwaysDependent;
|
||||
}
|
||||
return inherited::ComputeLambdaDependency(LSI);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3963,6 +3963,9 @@ void ASTWriter::WriteIdentifierTable(Preprocessor &PP,
|
|||
}
|
||||
|
||||
void ASTWriter::handleVTable(CXXRecordDecl *RD) {
|
||||
if (!RD->isInNamedModule())
|
||||
return;
|
||||
|
||||
PendingEmittingVTables.push_back(RD);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@
|
|||
|
||||
#include "clang/StaticAnalyzer/Checkers/Taint.h"
|
||||
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
|
||||
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
|
||||
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
|
||||
#include <optional>
|
||||
|
||||
|
|
@ -256,6 +257,12 @@ std::vector<SymbolRef> taint::getTaintedSymbolsImpl(ProgramStateRef State,
|
|||
if (!Sym)
|
||||
return TaintedSymbols;
|
||||
|
||||
// HACK:https://discourse.llvm.org/t/rfc-make-istainted-and-complex-symbols-friends/79570
|
||||
if (const auto &Opts = State->getAnalysisManager().getAnalyzerOptions();
|
||||
Sym->computeComplexity() > Opts.MaxTaintedSymbolComplexity) {
|
||||
return {};
|
||||
}
|
||||
|
||||
// Traverse all the symbols this symbol depends on to see if any are tainted.
|
||||
for (SymbolRef SubSym : Sym->symbols()) {
|
||||
if (!isa<SymbolData>(SubSym))
|
||||
|
|
|
|||
|
|
@ -194,7 +194,16 @@ typedef u64 OFF64_T;
|
|||
#ifdef __SIZE_TYPE__
|
||||
typedef __SIZE_TYPE__ usize;
|
||||
#else
|
||||
// Since we use this for operator new, usize must match the real size_t, but on
|
||||
// 32-bit Windows the definition of uptr does not actually match uintptr_t or
|
||||
// size_t because we are working around typedef mismatches for the (S)SIZE_T
|
||||
// types used in interception.h.
|
||||
// Until the definition of uptr has been fixed we have to special case Win32.
|
||||
# if SANITIZER_WINDOWS && SANITIZER_WORDSIZE == 32
|
||||
typedef unsigned int usize;
|
||||
# else
|
||||
typedef uptr usize;
|
||||
# endif
|
||||
#endif
|
||||
|
||||
typedef u64 tid_t;
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@
|
|||
// access stat from asm/stat.h, without conflicting with definition in
|
||||
// sys/stat.h, we use this trick. sparc64 is similar, using
|
||||
// syscall(__NR_stat64) and struct kernel_stat64.
|
||||
# if SANITIZER_MIPS64 || SANITIZER_SPARC64
|
||||
# if SANITIZER_LINUX && (SANITIZER_MIPS64 || SANITIZER_SPARC64)
|
||||
# include <asm/unistd.h>
|
||||
# include <sys/types.h>
|
||||
# define stat kernel_stat
|
||||
|
|
|
|||
|
|
@ -70,10 +70,17 @@ void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {
|
|||
stack_frame.AddrStack.Offset = ctx.Rsp;
|
||||
# endif
|
||||
# else
|
||||
# if SANITIZER_ARM
|
||||
int machine_type = IMAGE_FILE_MACHINE_ARM;
|
||||
stack_frame.AddrPC.Offset = ctx.Pc;
|
||||
stack_frame.AddrFrame.Offset = ctx.R11;
|
||||
stack_frame.AddrStack.Offset = ctx.Sp;
|
||||
# else
|
||||
int machine_type = IMAGE_FILE_MACHINE_I386;
|
||||
stack_frame.AddrPC.Offset = ctx.Eip;
|
||||
stack_frame.AddrFrame.Offset = ctx.Ebp;
|
||||
stack_frame.AddrStack.Offset = ctx.Esp;
|
||||
# endif
|
||||
# endif
|
||||
stack_frame.AddrPC.Mode = AddrModeFlat;
|
||||
stack_frame.AddrFrame.Mode = AddrModeFlat;
|
||||
|
|
|
|||
|
|
@ -992,8 +992,13 @@ void SignalContext::InitPcSpBp() {
|
|||
sp = (uptr)context_record->Rsp;
|
||||
# endif
|
||||
# else
|
||||
# if SANITIZER_ARM
|
||||
bp = (uptr)context_record->R11;
|
||||
sp = (uptr)context_record->Sp;
|
||||
# else
|
||||
bp = (uptr)context_record->Ebp;
|
||||
sp = (uptr)context_record->Esp;
|
||||
# endif
|
||||
# endif
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@
|
|||
#ifndef _LIBCPP___ALGORITHM_THREE_WAY_COMP_REF_TYPE_H
|
||||
#define _LIBCPP___ALGORITHM_THREE_WAY_COMP_REF_TYPE_H
|
||||
|
||||
#include <__assert>
|
||||
#include <__compare/ordering.h>
|
||||
#include <__config>
|
||||
#include <__utility/declval.h>
|
||||
|
|
|
|||
|
|
@ -237,21 +237,21 @@ namespace std {
|
|||
# include <cstdint>
|
||||
# include <cstdlib>
|
||||
# include <cstring>
|
||||
# include <cwchar>
|
||||
# include <initializer_list>
|
||||
# include <limits>
|
||||
# include <locale>
|
||||
# include <new>
|
||||
# include <optional>
|
||||
# include <queue>
|
||||
# include <stack>
|
||||
# include <stdexcept>
|
||||
# include <string>
|
||||
# include <string_view>
|
||||
# include <tuple>
|
||||
#endif
|
||||
|
||||
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
|
||||
# include <locale>
|
||||
# include <queue>
|
||||
# include <stack>
|
||||
# if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
|
||||
# include <cwchar>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#endif // _LIBCPP_FORMAT
|
||||
|
|
|
|||
|
|
@ -1,4 +0,0 @@
|
|||
module MachO.compact_unwind_encoding [system] {
|
||||
header "compact_unwind_encoding.h"
|
||||
export *
|
||||
}
|
||||
|
|
@ -873,7 +873,6 @@ Defined *ObjcCategoryMerger::emitAndLinkProtocolList(
|
|||
infoCategoryWriter.catPtrListInfo.align);
|
||||
listSec->parent = infoCategoryWriter.catPtrListInfo.outputSection;
|
||||
listSec->live = true;
|
||||
addInputSection(listSec);
|
||||
|
||||
listSec->parent = infoCategoryWriter.catPtrListInfo.outputSection;
|
||||
|
||||
|
|
@ -889,6 +888,7 @@ Defined *ObjcCategoryMerger::emitAndLinkProtocolList(
|
|||
|
||||
ptrListSym->used = true;
|
||||
parentSym->getObjectFile()->symbols.push_back(ptrListSym);
|
||||
addInputSection(listSec);
|
||||
|
||||
createSymbolReference(parentSym, ptrListSym, linkAtOffset,
|
||||
infoCategoryWriter.catBodyInfo.relocTemplate);
|
||||
|
|
@ -933,7 +933,6 @@ void ObjcCategoryMerger::emitAndLinkPointerList(
|
|||
infoCategoryWriter.catPtrListInfo.align);
|
||||
listSec->parent = infoCategoryWriter.catPtrListInfo.outputSection;
|
||||
listSec->live = true;
|
||||
addInputSection(listSec);
|
||||
|
||||
listSec->parent = infoCategoryWriter.catPtrListInfo.outputSection;
|
||||
|
||||
|
|
@ -949,6 +948,7 @@ void ObjcCategoryMerger::emitAndLinkPointerList(
|
|||
|
||||
ptrListSym->used = true;
|
||||
parentSym->getObjectFile()->symbols.push_back(ptrListSym);
|
||||
addInputSection(listSec);
|
||||
|
||||
createSymbolReference(parentSym, ptrListSym, linkAtOffset,
|
||||
infoCategoryWriter.catBodyInfo.relocTemplate);
|
||||
|
|
@ -974,7 +974,6 @@ ObjcCategoryMerger::emitCatListEntrySec(const std::string &forCategoryName,
|
|||
bodyData, infoCategoryWriter.catListInfo.align);
|
||||
newCatList->parent = infoCategoryWriter.catListInfo.outputSection;
|
||||
newCatList->live = true;
|
||||
addInputSection(newCatList);
|
||||
|
||||
newCatList->parent = infoCategoryWriter.catListInfo.outputSection;
|
||||
|
||||
|
|
@ -990,6 +989,7 @@ ObjcCategoryMerger::emitCatListEntrySec(const std::string &forCategoryName,
|
|||
|
||||
catListSym->used = true;
|
||||
objFile->symbols.push_back(catListSym);
|
||||
addInputSection(newCatList);
|
||||
return catListSym;
|
||||
}
|
||||
|
||||
|
|
@ -1012,7 +1012,6 @@ Defined *ObjcCategoryMerger::emitCategoryBody(const std::string &name,
|
|||
bodyData, infoCategoryWriter.catBodyInfo.align);
|
||||
newBodySec->parent = infoCategoryWriter.catBodyInfo.outputSection;
|
||||
newBodySec->live = true;
|
||||
addInputSection(newBodySec);
|
||||
|
||||
std::string symName =
|
||||
objc::symbol_names::category + baseClassName + "(" + name + ")";
|
||||
|
|
@ -1025,6 +1024,7 @@ Defined *ObjcCategoryMerger::emitCategoryBody(const std::string &name,
|
|||
|
||||
catBodySym->used = true;
|
||||
objFile->symbols.push_back(catBodySym);
|
||||
addInputSection(newBodySec);
|
||||
|
||||
createSymbolReference(catBodySym, nameSym, catLayout.nameOffset,
|
||||
infoCategoryWriter.catBodyInfo.relocTemplate);
|
||||
|
|
@ -1245,7 +1245,6 @@ void ObjcCategoryMerger::generateCatListForNonErasedCategories(
|
|||
infoCategoryWriter.catListInfo.align);
|
||||
listSec->parent = infoCategoryWriter.catListInfo.outputSection;
|
||||
listSec->live = true;
|
||||
addInputSection(listSec);
|
||||
|
||||
std::string slotSymName = "<__objc_catlist slot for category ";
|
||||
slotSymName += nonErasedCatBody->getName();
|
||||
|
|
@ -1260,6 +1259,7 @@ void ObjcCategoryMerger::generateCatListForNonErasedCategories(
|
|||
|
||||
catListSlotSym->used = true;
|
||||
objFile->symbols.push_back(catListSlotSym);
|
||||
addInputSection(listSec);
|
||||
|
||||
// Now link the category body into the newly created slot
|
||||
createSymbolReference(catListSlotSym, nonErasedCatBody, 0,
|
||||
|
|
|
|||
|
|
@ -13,11 +13,11 @@
|
|||
// Specialized loads from packet
|
||||
let TargetPrefix = "bpf" in { // All intrinsics start with "llvm.bpf."
|
||||
def int_bpf_load_byte : ClangBuiltin<"__builtin_bpf_load_byte">,
|
||||
Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>;
|
||||
DefaultAttrsIntrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>;
|
||||
def int_bpf_load_half : ClangBuiltin<"__builtin_bpf_load_half">,
|
||||
Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>;
|
||||
DefaultAttrsIntrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>;
|
||||
def int_bpf_load_word : ClangBuiltin<"__builtin_bpf_load_word">,
|
||||
Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>;
|
||||
DefaultAttrsIntrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>;
|
||||
def int_bpf_pseudo : ClangBuiltin<"__builtin_bpf_pseudo">,
|
||||
Intrinsic<[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty]>;
|
||||
def int_bpf_preserve_field_info : ClangBuiltin<"__builtin_bpf_preserve_field_info">,
|
||||
|
|
|
|||
|
|
@ -293,6 +293,13 @@ bool DwarfEHPrepare::InsertUnwindResumeCalls() {
|
|||
// Call the function.
|
||||
CallInst *CI =
|
||||
CallInst::Create(RewindFunction, RewindFunctionArgs, "", UnwindBB);
|
||||
// The verifier requires that all calls of debug-info-bearing functions
|
||||
// from debug-info-bearing functions have a debug location (for inlining
|
||||
// purposes). Assign a dummy location to satisfy the constraint.
|
||||
Function *RewindFn = dyn_cast<Function>(RewindFunction.getCallee());
|
||||
if (RewindFn && RewindFn->getSubprogram())
|
||||
if (DISubprogram *SP = F.getSubprogram())
|
||||
CI->setDebugLoc(DILocation::get(SP->getContext(), 0, 0, SP));
|
||||
CI->setCallingConv(RewindFunctionCallingConv);
|
||||
|
||||
// We never expect _Unwind_Resume to return.
|
||||
|
|
|
|||
|
|
@ -528,8 +528,16 @@ bool MachinePipeliner::useSwingModuloScheduler() {
|
|||
}
|
||||
|
||||
bool MachinePipeliner::useWindowScheduler(bool Changed) {
|
||||
// WindowScheduler does not work when it is off or when SwingModuloScheduler
|
||||
// is successfully scheduled.
|
||||
// WindowScheduler does not work for following cases:
|
||||
// 1. when it is off.
|
||||
// 2. when SwingModuloScheduler is successfully scheduled.
|
||||
// 3. when pragma II is enabled.
|
||||
if (II_setByPragma) {
|
||||
LLVM_DEBUG(dbgs() << "Window scheduling is disabled when "
|
||||
"llvm.loop.pipeline.initiationinterval is set.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
return WindowSchedulingOption == WindowSchedulingFlag::WS_Force ||
|
||||
(WindowSchedulingOption == WindowSchedulingFlag::WS_On && !Changed);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15680,13 +15680,16 @@ SDValue DAGCombiner::visitFREEZE(SDNode *N) {
|
|||
}
|
||||
}
|
||||
|
||||
SmallSetVector<SDValue, 8> MaybePoisonOperands;
|
||||
for (SDValue Op : N0->ops()) {
|
||||
SmallSet<SDValue, 8> MaybePoisonOperands;
|
||||
SmallVector<unsigned, 8> MaybePoisonOperandNumbers;
|
||||
for (auto [OpNo, Op] : enumerate(N0->ops())) {
|
||||
if (DAG.isGuaranteedNotToBeUndefOrPoison(Op, /*PoisonOnly*/ false,
|
||||
/*Depth*/ 1))
|
||||
continue;
|
||||
bool HadMaybePoisonOperands = !MaybePoisonOperands.empty();
|
||||
bool IsNewMaybePoisonOperand = MaybePoisonOperands.insert(Op);
|
||||
bool IsNewMaybePoisonOperand = MaybePoisonOperands.insert(Op).second;
|
||||
if (IsNewMaybePoisonOperand)
|
||||
MaybePoisonOperandNumbers.push_back(OpNo);
|
||||
if (!HadMaybePoisonOperands)
|
||||
continue;
|
||||
if (IsNewMaybePoisonOperand && !AllowMultipleMaybePoisonOperands) {
|
||||
|
|
@ -15698,7 +15701,18 @@ SDValue DAGCombiner::visitFREEZE(SDNode *N) {
|
|||
// it could create undef or poison due to it's poison-generating flags.
|
||||
// So not finding any maybe-poison operands is fine.
|
||||
|
||||
for (SDValue MaybePoisonOperand : MaybePoisonOperands) {
|
||||
for (unsigned OpNo : MaybePoisonOperandNumbers) {
|
||||
// N0 can mutate during iteration, so make sure to refetch the maybe poison
|
||||
// operands via the operand numbers. The typical scenario is that we have
|
||||
// something like this
|
||||
// t262: i32 = freeze t181
|
||||
// t150: i32 = ctlz_zero_undef t262
|
||||
// t184: i32 = ctlz_zero_undef t181
|
||||
// t268: i32 = select_cc t181, Constant:i32<0>, t184, t186, setne:ch
|
||||
// When freezing the t181 operand we get t262 back, and then the
|
||||
// ReplaceAllUsesOfValueWith call will not only replace t181 by t262, but
|
||||
// also recursively replace t184 by t150.
|
||||
SDValue MaybePoisonOperand = N->getOperand(0).getOperand(OpNo);
|
||||
// Don't replace every single UNDEF everywhere with frozen UNDEF, though.
|
||||
if (MaybePoisonOperand.getOpcode() == ISD::UNDEF)
|
||||
continue;
|
||||
|
|
|
|||
|
|
@ -232,8 +232,11 @@ bool WindowScheduler::initialize() {
|
|||
return false;
|
||||
}
|
||||
for (auto &Def : MI.all_defs())
|
||||
if (Def.isReg() && Def.getReg().isPhysical())
|
||||
if (Def.isReg() && Def.getReg().isPhysical()) {
|
||||
LLVM_DEBUG(dbgs() << "Physical registers are not supported in "
|
||||
"window scheduling!\n");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (SchedInstrNum <= WindowRegionLimit) {
|
||||
LLVM_DEBUG(dbgs() << "There are too few MIs in the window region!\n");
|
||||
|
|
@ -437,14 +440,17 @@ int WindowScheduler::calculateMaxCycle(ScheduleDAGInstrs &DAG,
|
|||
int PredCycle = getOriCycle(PredMI);
|
||||
ExpectCycle = std::max(ExpectCycle, PredCycle + (int)Pred.getLatency());
|
||||
}
|
||||
// ResourceManager can be used to detect resource conflicts between the
|
||||
// current MI and the previously inserted MIs.
|
||||
while (!RM.canReserveResources(*SU, CurCycle) || CurCycle < ExpectCycle) {
|
||||
++CurCycle;
|
||||
if (CurCycle == (int)WindowIILimit)
|
||||
return CurCycle;
|
||||
// Zero cost instructions do not need to check resource.
|
||||
if (!TII->isZeroCost(MI.getOpcode())) {
|
||||
// ResourceManager can be used to detect resource conflicts between the
|
||||
// current MI and the previously inserted MIs.
|
||||
while (!RM.canReserveResources(*SU, CurCycle) || CurCycle < ExpectCycle) {
|
||||
++CurCycle;
|
||||
if (CurCycle == (int)WindowIILimit)
|
||||
return CurCycle;
|
||||
}
|
||||
RM.reserveResources(*SU, CurCycle);
|
||||
}
|
||||
RM.reserveResources(*SU, CurCycle);
|
||||
OriToCycle[getOriMI(&MI)] = CurCycle;
|
||||
LLVM_DEBUG(dbgs() << "\tCycle " << CurCycle << " [S."
|
||||
<< getOriStage(getOriMI(&MI), Offset) << "]: " << MI);
|
||||
|
|
@ -485,6 +491,7 @@ int WindowScheduler::calculateMaxCycle(ScheduleDAGInstrs &DAG,
|
|||
// ========================================
|
||||
int WindowScheduler::calculateStallCycle(unsigned Offset, int MaxCycle) {
|
||||
int MaxStallCycle = 0;
|
||||
int CurrentII = MaxCycle + 1;
|
||||
auto Range = getScheduleRange(Offset, SchedInstrNum);
|
||||
for (auto &MI : Range) {
|
||||
auto *SU = TripleDAG->getSUnit(&MI);
|
||||
|
|
@ -492,8 +499,8 @@ int WindowScheduler::calculateStallCycle(unsigned Offset, int MaxCycle) {
|
|||
for (auto &Succ : SU->Succs) {
|
||||
if (Succ.isWeak() || Succ.getSUnit() == &TripleDAG->ExitSU)
|
||||
continue;
|
||||
// If the expected cycle does not exceed MaxCycle, no check is needed.
|
||||
if (DefCycle + (int)Succ.getLatency() <= MaxCycle)
|
||||
// If the expected cycle does not exceed CurrentII, no check is needed.
|
||||
if (DefCycle + (int)Succ.getLatency() <= CurrentII)
|
||||
continue;
|
||||
// If the cycle of the scheduled MI A is less than that of the scheduled
|
||||
// MI B, the scheduling will fail because the lifetime of the
|
||||
|
|
@ -503,7 +510,7 @@ int WindowScheduler::calculateStallCycle(unsigned Offset, int MaxCycle) {
|
|||
if (DefCycle < UseCycle)
|
||||
return WindowIILimit;
|
||||
// Get the stall cycle introduced by the register between two trips.
|
||||
int StallCycle = DefCycle + (int)Succ.getLatency() - MaxCycle - UseCycle;
|
||||
int StallCycle = DefCycle + (int)Succ.getLatency() - CurrentII - UseCycle;
|
||||
MaxStallCycle = std::max(MaxStallCycle, StallCycle);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -961,9 +961,13 @@ void BasicBlock::spliceDebugInfoImpl(BasicBlock::iterator Dest, BasicBlock *Src,
|
|||
// Detach the marker at Dest -- this lets us move the "====" DbgRecords
|
||||
// around.
|
||||
DbgMarker *DestMarker = nullptr;
|
||||
if (Dest != end()) {
|
||||
if ((DestMarker = getMarker(Dest)))
|
||||
if ((DestMarker = getMarker(Dest))) {
|
||||
if (Dest == end()) {
|
||||
assert(DestMarker == getTrailingDbgRecords());
|
||||
deleteTrailingDbgRecords();
|
||||
} else {
|
||||
DestMarker->removeFromParent();
|
||||
}
|
||||
}
|
||||
|
||||
// If we're moving the tail range of DbgRecords (":::"), absorb them into the
|
||||
|
|
@ -1005,22 +1009,14 @@ void BasicBlock::spliceDebugInfoImpl(BasicBlock::iterator Dest, BasicBlock *Src,
|
|||
} else {
|
||||
// Insert them right at the start of the range we moved, ahead of First
|
||||
// and the "++++" DbgRecords.
|
||||
// This also covers the rare circumstance where we insert at end(), and we
|
||||
// did not generate the iterator with begin() / getFirstInsertionPt(),
|
||||
// meaning any trailing debug-info at the end of the block would
|
||||
// "normally" have been pushed in front of "First". We move it there now.
|
||||
DbgMarker *FirstMarker = createMarker(First);
|
||||
FirstMarker->absorbDebugValues(*DestMarker, true);
|
||||
}
|
||||
DestMarker->eraseFromParent();
|
||||
} else if (Dest == end() && !InsertAtHead) {
|
||||
// In the rare circumstance where we insert at end(), and we did not
|
||||
// generate the iterator with begin() / getFirstInsertionPt(), it means
|
||||
// any trailing debug-info at the end of the block would "normally" have
|
||||
// been pushed in front of "First". Move it there now.
|
||||
DbgMarker *TrailingDbgRecords = getTrailingDbgRecords();
|
||||
if (TrailingDbgRecords) {
|
||||
DbgMarker *FirstMarker = createMarker(First);
|
||||
FirstMarker->absorbDebugValues(*TrailingDbgRecords, true);
|
||||
TrailingDbgRecords->eraseFromParent();
|
||||
deleteTrailingDbgRecords();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -473,11 +473,12 @@ DbgLabelRecord::createDebugIntrinsic(Module *M,
|
|||
|
||||
Value *DbgVariableRecord::getAddress() const {
|
||||
auto *MD = getRawAddress();
|
||||
if (auto *V = dyn_cast<ValueAsMetadata>(MD))
|
||||
if (auto *V = dyn_cast_or_null<ValueAsMetadata>(MD))
|
||||
return V->getValue();
|
||||
|
||||
// When the value goes to null, it gets replaced by an empty MDNode.
|
||||
assert(!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode");
|
||||
assert(!MD ||
|
||||
!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -88,6 +88,20 @@ void TypeFinder::run(const Module &M, bool onlyNamed) {
|
|||
for (const auto &MD : MDForInst)
|
||||
incorporateMDNode(MD.second);
|
||||
MDForInst.clear();
|
||||
|
||||
// Incorporate types hiding in variable-location information.
|
||||
for (const auto &Dbg : I.getDbgRecordRange()) {
|
||||
// Pick out records that have Values.
|
||||
if (const DbgVariableRecord *DVI =
|
||||
dyn_cast<DbgVariableRecord>(&Dbg)) {
|
||||
for (Value *V : DVI->location_ops())
|
||||
incorporateValue(V);
|
||||
if (DVI->isDbgAssign()) {
|
||||
if (Value *Addr = DVI->getAddress())
|
||||
incorporateValue(Addr);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ using namespace llvm;
|
|||
#include "llvm/ADT/Twine.h"
|
||||
|
||||
#include <set>
|
||||
#include <unordered_map>
|
||||
|
||||
#include <z3.h>
|
||||
|
||||
|
|
|
|||
|
|
@ -895,7 +895,12 @@ def ProcessorFeatures {
|
|||
FeatureLSE, FeaturePAuth,
|
||||
FeatureRAS, FeatureRCPC, FeatureRDM,
|
||||
FeatureBF16, FeatureDotProd, FeatureMatMulInt8, FeatureSSBS];
|
||||
list<SubtargetFeature> AppleM4 = [HasV9_2aOps, FeatureSHA2, FeatureFPARMv8,
|
||||
// Technically apple-m4 is v9.2a, but we can't use that here.
|
||||
// Historically, llvm defined v9.0a as requiring SVE, but it's optional
|
||||
// according to the Arm ARM, and not supported by the core. We decoupled the
|
||||
// two in the clang driver and in the backend subtarget features, but it's
|
||||
// still an issue in the clang frontend. v8.7a is the next closest choice.
|
||||
list<SubtargetFeature> AppleM4 = [HasV8_7aOps, FeatureSHA2, FeatureFPARMv8,
|
||||
FeatureNEON, FeaturePerfMon, FeatureSHA3,
|
||||
FeatureFullFP16, FeatureFP16FML,
|
||||
FeatureAES, FeatureBF16,
|
||||
|
|
|
|||
|
|
@ -953,6 +953,12 @@ def FeatureRequiredExportPriority : SubtargetFeature<"required-export-priority",
|
|||
"Export priority must be explicitly manipulated on GFX11.5"
|
||||
>;
|
||||
|
||||
def FeatureVmemWriteVgprInOrder : SubtargetFeature<"vmem-write-vgpr-in-order",
|
||||
"HasVmemWriteVgprInOrder",
|
||||
"true",
|
||||
"VMEM instructions of the same type write VGPR results in order"
|
||||
>;
|
||||
|
||||
//===------------------------------------------------------------===//
|
||||
// Subtarget Features (options and debugging)
|
||||
//===------------------------------------------------------------===//
|
||||
|
|
@ -1123,7 +1129,8 @@ def FeatureSouthernIslands : GCNSubtargetFeatureGeneration<"SOUTHERN_ISLANDS",
|
|||
FeatureDsSrc2Insts, FeatureLDSBankCount32, FeatureMovrel,
|
||||
FeatureTrigReducedRange, FeatureExtendedImageInsts, FeatureImageInsts,
|
||||
FeatureGDS, FeatureGWS, FeatureDefaultComponentZero,
|
||||
FeatureAtomicFMinFMaxF32GlobalInsts, FeatureAtomicFMinFMaxF64GlobalInsts
|
||||
FeatureAtomicFMinFMaxF32GlobalInsts, FeatureAtomicFMinFMaxF64GlobalInsts,
|
||||
FeatureVmemWriteVgprInOrder
|
||||
]
|
||||
>;
|
||||
|
||||
|
|
@ -1136,7 +1143,8 @@ def FeatureSeaIslands : GCNSubtargetFeatureGeneration<"SEA_ISLANDS",
|
|||
FeatureDsSrc2Insts, FeatureExtendedImageInsts, FeatureUnalignedBufferAccess,
|
||||
FeatureImageInsts, FeatureGDS, FeatureGWS, FeatureDefaultComponentZero,
|
||||
FeatureAtomicFMinFMaxF32GlobalInsts, FeatureAtomicFMinFMaxF64GlobalInsts,
|
||||
FeatureAtomicFMinFMaxF32FlatInsts, FeatureAtomicFMinFMaxF64FlatInsts
|
||||
FeatureAtomicFMinFMaxF32FlatInsts, FeatureAtomicFMinFMaxF64FlatInsts,
|
||||
FeatureVmemWriteVgprInOrder
|
||||
]
|
||||
>;
|
||||
|
||||
|
|
@ -1152,7 +1160,7 @@ def FeatureVolcanicIslands : GCNSubtargetFeatureGeneration<"VOLCANIC_ISLANDS",
|
|||
FeatureGFX7GFX8GFX9Insts, FeatureSMemTimeInst, FeatureMadMacF32Insts,
|
||||
FeatureDsSrc2Insts, FeatureExtendedImageInsts, FeatureFastDenormalF32,
|
||||
FeatureUnalignedBufferAccess, FeatureImageInsts, FeatureGDS, FeatureGWS,
|
||||
FeatureDefaultComponentZero
|
||||
FeatureDefaultComponentZero, FeatureVmemWriteVgprInOrder
|
||||
]
|
||||
>;
|
||||
|
||||
|
|
@ -1170,7 +1178,8 @@ def FeatureGFX9 : GCNSubtargetFeatureGeneration<"GFX9",
|
|||
FeatureScalarFlatScratchInsts, FeatureScalarAtomics, FeatureR128A16,
|
||||
FeatureA16, FeatureSMemTimeInst, FeatureFastDenormalF32, FeatureSupportsXNACK,
|
||||
FeatureUnalignedBufferAccess, FeatureUnalignedDSAccess,
|
||||
FeatureNegativeScratchOffsetBug, FeatureGWS, FeatureDefaultComponentZero
|
||||
FeatureNegativeScratchOffsetBug, FeatureGWS, FeatureDefaultComponentZero,
|
||||
FeatureVmemWriteVgprInOrder
|
||||
]
|
||||
>;
|
||||
|
||||
|
|
@ -1193,7 +1202,8 @@ def FeatureGFX10 : GCNSubtargetFeatureGeneration<"GFX10",
|
|||
FeatureGDS, FeatureGWS, FeatureDefaultComponentZero,
|
||||
FeatureMaxHardClauseLength63,
|
||||
FeatureAtomicFMinFMaxF32GlobalInsts, FeatureAtomicFMinFMaxF64GlobalInsts,
|
||||
FeatureAtomicFMinFMaxF32FlatInsts, FeatureAtomicFMinFMaxF64FlatInsts
|
||||
FeatureAtomicFMinFMaxF32FlatInsts, FeatureAtomicFMinFMaxF64FlatInsts,
|
||||
FeatureVmemWriteVgprInOrder
|
||||
]
|
||||
>;
|
||||
|
||||
|
|
@ -1215,7 +1225,8 @@ def FeatureGFX11 : GCNSubtargetFeatureGeneration<"GFX11",
|
|||
FeatureUnalignedBufferAccess, FeatureUnalignedDSAccess, FeatureGDS,
|
||||
FeatureGWS, FeatureDefaultComponentZero,
|
||||
FeatureMaxHardClauseLength32,
|
||||
FeatureAtomicFMinFMaxF32GlobalInsts, FeatureAtomicFMinFMaxF32FlatInsts
|
||||
FeatureAtomicFMinFMaxF32GlobalInsts, FeatureAtomicFMinFMaxF32FlatInsts,
|
||||
FeatureVmemWriteVgprInOrder
|
||||
]
|
||||
>;
|
||||
|
||||
|
|
|
|||
|
|
@ -239,6 +239,7 @@ protected:
|
|||
bool HasVALUTransUseHazard = false;
|
||||
bool HasForceStoreSC0SC1 = false;
|
||||
bool HasRequiredExportPriority = false;
|
||||
bool HasVmemWriteVgprInOrder = false;
|
||||
|
||||
bool RequiresCOV6 = false;
|
||||
|
||||
|
|
@ -1285,10 +1286,18 @@ public:
|
|||
|
||||
bool hasRequiredExportPriority() const { return HasRequiredExportPriority; }
|
||||
|
||||
bool hasVmemWriteVgprInOrder() const { return HasVmemWriteVgprInOrder; }
|
||||
|
||||
/// \returns true if the target uses LOADcnt/SAMPLEcnt/BVHcnt, DScnt/KMcnt
|
||||
/// and STOREcnt rather than VMcnt, LGKMcnt and VScnt respectively.
|
||||
bool hasExtendedWaitCounts() const { return getGeneration() >= GFX12; }
|
||||
|
||||
/// \returns true if inline constants are not supported for F16 pseudo
|
||||
/// scalar transcendentals.
|
||||
bool hasNoF16PseudoScalarTransInlineConstants() const {
|
||||
return getGeneration() == GFX12;
|
||||
}
|
||||
|
||||
/// \returns The maximum number of instructions that can be enclosed in an
|
||||
/// S_CLAUSE on the given subtarget, or 0 for targets that do not support that
|
||||
/// instruction.
|
||||
|
|
|
|||
|
|
@ -1778,11 +1778,12 @@ bool SIInsertWaitcnts::generateWaitcntInstBefore(MachineInstr &MI,
|
|||
if (IsVGPR) {
|
||||
// RAW always needs an s_waitcnt. WAW needs an s_waitcnt unless the
|
||||
// previous write and this write are the same type of VMEM
|
||||
// instruction, in which case they're guaranteed to write their
|
||||
// results in order anyway.
|
||||
// instruction, in which case they are (in some architectures)
|
||||
// guaranteed to write their results in order anyway.
|
||||
if (Op.isUse() || !updateVMCntOnly(MI) ||
|
||||
ScoreBrackets.hasOtherPendingVmemTypes(RegNo,
|
||||
getVmemType(MI))) {
|
||||
getVmemType(MI)) ||
|
||||
!ST->hasVmemWriteVgprInOrder()) {
|
||||
ScoreBrackets.determineWait(LOAD_CNT, RegNo, Wait);
|
||||
ScoreBrackets.determineWait(SAMPLE_CNT, RegNo, Wait);
|
||||
ScoreBrackets.determineWait(BVH_CNT, RegNo, Wait);
|
||||
|
|
@ -2389,7 +2390,7 @@ bool SIInsertWaitcnts::shouldFlushVmCnt(MachineLoop *ML,
|
|||
}
|
||||
if (!ST->hasVscnt() && HasVMemStore && !HasVMemLoad && UsesVgprLoadedOutside)
|
||||
return true;
|
||||
return HasVMemLoad && UsesVgprLoadedOutside;
|
||||
return HasVMemLoad && UsesVgprLoadedOutside && ST->hasVmemWriteVgprInOrder();
|
||||
}
|
||||
|
||||
bool SIInsertWaitcnts::runOnMachineFunction(MachineFunction &MF) {
|
||||
|
|
|
|||
|
|
@ -5768,6 +5768,10 @@ bool SIInstrInfo::isOperandLegal(const MachineInstr &MI, unsigned OpIdx,
|
|||
return false;
|
||||
}
|
||||
}
|
||||
} else if (ST.hasNoF16PseudoScalarTransInlineConstants() && !MO->isReg() &&
|
||||
isF16PseudoScalarTrans(MI.getOpcode()) &&
|
||||
isInlineConstant(*MO, OpInfo)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (MO->isReg()) {
|
||||
|
|
|
|||
|
|
@ -946,6 +946,14 @@ public:
|
|||
Opcode == AMDGPU::DS_GWS_BARRIER;
|
||||
}
|
||||
|
||||
static bool isF16PseudoScalarTrans(unsigned Opcode) {
|
||||
return Opcode == AMDGPU::V_S_EXP_F16_e64 ||
|
||||
Opcode == AMDGPU::V_S_LOG_F16_e64 ||
|
||||
Opcode == AMDGPU::V_S_RCP_F16_e64 ||
|
||||
Opcode == AMDGPU::V_S_RSQ_F16_e64 ||
|
||||
Opcode == AMDGPU::V_S_SQRT_F16_e64;
|
||||
}
|
||||
|
||||
static bool doesNotReadTiedSource(const MachineInstr &MI) {
|
||||
return MI.getDesc().TSFlags & SIInstrFlags::TiedSourceNotRead;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ class AVRAsmParser : public MCTargetAsmParser {
|
|||
int parseRegisterName();
|
||||
int parseRegister(bool RestoreOnFailure = false);
|
||||
bool tryParseRegisterOperand(OperandVector &Operands);
|
||||
bool tryParseExpression(OperandVector &Operands);
|
||||
bool tryParseExpression(OperandVector &Operands, int64_t offset);
|
||||
bool tryParseRelocExpression(OperandVector &Operands);
|
||||
void eatComma();
|
||||
|
||||
|
|
@ -418,7 +418,7 @@ bool AVRAsmParser::tryParseRegisterOperand(OperandVector &Operands) {
|
|||
return false;
|
||||
}
|
||||
|
||||
bool AVRAsmParser::tryParseExpression(OperandVector &Operands) {
|
||||
bool AVRAsmParser::tryParseExpression(OperandVector &Operands, int64_t offset) {
|
||||
SMLoc S = Parser.getTok().getLoc();
|
||||
|
||||
if (!tryParseRelocExpression(Operands))
|
||||
|
|
@ -437,6 +437,11 @@ bool AVRAsmParser::tryParseExpression(OperandVector &Operands) {
|
|||
if (getParser().parseExpression(Expression))
|
||||
return true;
|
||||
|
||||
if (offset) {
|
||||
Expression = MCBinaryExpr::createAdd(
|
||||
Expression, MCConstantExpr::create(offset, getContext()), getContext());
|
||||
}
|
||||
|
||||
SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
|
||||
Operands.push_back(AVROperand::CreateImm(Expression, S, E));
|
||||
return false;
|
||||
|
|
@ -529,8 +534,9 @@ bool AVRAsmParser::parseOperand(OperandVector &Operands, bool maybeReg) {
|
|||
[[fallthrough]];
|
||||
case AsmToken::LParen:
|
||||
case AsmToken::Integer:
|
||||
return tryParseExpression(Operands, 0);
|
||||
case AsmToken::Dot:
|
||||
return tryParseExpression(Operands);
|
||||
return tryParseExpression(Operands, 2);
|
||||
case AsmToken::Plus:
|
||||
case AsmToken::Minus: {
|
||||
// If the sign preceeds a number, parse the number,
|
||||
|
|
@ -540,7 +546,7 @@ bool AVRAsmParser::parseOperand(OperandVector &Operands, bool maybeReg) {
|
|||
case AsmToken::BigNum:
|
||||
case AsmToken::Identifier:
|
||||
case AsmToken::Real:
|
||||
if (!tryParseExpression(Operands))
|
||||
if (!tryParseExpression(Operands, 0))
|
||||
return false;
|
||||
break;
|
||||
default:
|
||||
|
|
@ -643,6 +649,7 @@ bool AVRAsmParser::ParseInstruction(ParseInstructionInfo &Info,
|
|||
// These specific operands should be treated as addresses/symbols/labels,
|
||||
// other than registers.
|
||||
bool maybeReg = true;
|
||||
|
||||
if (OperandNum == 1) {
|
||||
std::array<StringRef, 8> Insts = {"lds", "adiw", "sbiw", "ldi"};
|
||||
for (auto Inst : Insts) {
|
||||
|
|
|
|||
|
|
@ -94,6 +94,9 @@ static void adjustRelativeBranch(unsigned Size, const MCFixup &Fixup,
|
|||
|
||||
// Rightshifts the value by one.
|
||||
AVR::fixups::adjustBranchTarget(Value);
|
||||
|
||||
// Jumps are relative to the current instruction.
|
||||
Value -= 1;
|
||||
}
|
||||
|
||||
/// 22-bit absolute fixup.
|
||||
|
|
@ -513,15 +516,10 @@ bool AVRAsmBackend::shouldForceRelocation(const MCAssembler &Asm,
|
|||
switch ((unsigned)Fixup.getKind()) {
|
||||
default:
|
||||
return Fixup.getKind() >= FirstLiteralRelocationKind;
|
||||
// Fixups which should always be recorded as relocations.
|
||||
case AVR::fixup_7_pcrel:
|
||||
case AVR::fixup_13_pcrel:
|
||||
// Do not force relocation for PC relative branch like 'rjmp .',
|
||||
// 'rcall . - off' and 'breq . + off'.
|
||||
if (const auto *SymA = Target.getSymA())
|
||||
if (SymA->getSymbol().getName().size() == 0)
|
||||
return false;
|
||||
[[fallthrough]];
|
||||
// Always resolve relocations for PC-relative branches
|
||||
return false;
|
||||
case AVR::fixup_call:
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9338,14 +9338,18 @@ SDValue PPCTargetLowering::LowerBITCAST(SDValue Op, SelectionDAG &DAG) const {
|
|||
SDLoc dl(Op);
|
||||
SDValue Op0 = Op->getOperand(0);
|
||||
|
||||
SDValue Lo = Op0.getOperand(0);
|
||||
SDValue Hi = Op0.getOperand(1);
|
||||
|
||||
if ((Op.getValueType() != MVT::f128) ||
|
||||
(Op0.getOpcode() != ISD::BUILD_PAIR) ||
|
||||
(Op0.getOperand(0).getValueType() != MVT::i64) ||
|
||||
(Op0.getOperand(1).getValueType() != MVT::i64) || !Subtarget.isPPC64())
|
||||
(Op0.getOpcode() != ISD::BUILD_PAIR) || (Lo.getValueType() != MVT::i64) ||
|
||||
(Hi.getValueType() != MVT::i64) || !Subtarget.isPPC64())
|
||||
return SDValue();
|
||||
|
||||
return DAG.getNode(PPCISD::BUILD_FP128, dl, MVT::f128, Op0.getOperand(0),
|
||||
Op0.getOperand(1));
|
||||
if (!Subtarget.isLittleEndian())
|
||||
std::swap(Lo, Hi);
|
||||
|
||||
return DAG.getNode(PPCISD::BUILD_FP128, dl, MVT::f128, Lo, Hi);
|
||||
}
|
||||
|
||||
static const SDValue *getNormalLoadInput(const SDValue &Op, bool &IsPermuted) {
|
||||
|
|
|
|||
|
|
@ -2014,9 +2014,9 @@ def SLBSYNC : XForm_0<31, 338, (outs), (ins), "slbsync", IIC_SprSLBSYNC, []>;
|
|||
} // IsISA3_0
|
||||
|
||||
def : Pat<(int_ppc_stdcx ForceXForm:$dst, g8rc:$A),
|
||||
(STDCX g8rc:$A, ForceXForm:$dst)>;
|
||||
(RLWINM (STDCX g8rc:$A, ForceXForm:$dst), 31, 31, 31)>;
|
||||
def : Pat<(PPCStoreCond ForceXForm:$dst, g8rc:$A, 8),
|
||||
(STDCX g8rc:$A, ForceXForm:$dst)>;
|
||||
(RLWINM (STDCX g8rc:$A, ForceXForm:$dst), 31, 31, 31)>;
|
||||
|
||||
def : Pat<(i64 (int_ppc_mfspr timm:$SPR)),
|
||||
(MFSPR8 $SPR)>;
|
||||
|
|
|
|||
|
|
@ -5286,13 +5286,13 @@ def : Pat<(i64 (bitreverse i64:$A)),
|
|||
(OR8 (RLDICR DWBytes7654.DWord, 32, 31), DWBytes3210.DWord)>;
|
||||
|
||||
def : Pat<(int_ppc_stwcx ForceXForm:$dst, gprc:$A),
|
||||
(STWCX gprc:$A, ForceXForm:$dst)>;
|
||||
(RLWINM (STWCX gprc:$A, ForceXForm:$dst), 31, 31, 31)>;
|
||||
def : Pat<(PPCStoreCond ForceXForm:$dst, gprc:$A, 4),
|
||||
(STWCX gprc:$A, ForceXForm:$dst)>;
|
||||
(RLWINM (STWCX gprc:$A, ForceXForm:$dst), 31, 31, 31)>;
|
||||
def : Pat<(int_ppc_stbcx ForceXForm:$dst, gprc:$A),
|
||||
(STBCX gprc:$A, ForceXForm:$dst)>;
|
||||
(RLWINM (STBCX gprc:$A, ForceXForm:$dst), 31, 31, 31)>;
|
||||
def : Pat<(PPCStoreCond ForceXForm:$dst, gprc:$A, 1),
|
||||
(STBCX gprc:$A, ForceXForm:$dst)>;
|
||||
(RLWINM (STBCX gprc:$A, ForceXForm:$dst), 31, 31, 31)>;
|
||||
|
||||
def : Pat<(int_ppc_fcfid f64:$A),
|
||||
(XSCVSXDDP $A)>;
|
||||
|
|
@ -5322,9 +5322,9 @@ def : Pat<(int_ppc_mtmsr gprc:$RS),
|
|||
|
||||
let Predicates = [IsISA2_07] in {
|
||||
def : Pat<(int_ppc_sthcx ForceXForm:$dst, gprc:$A),
|
||||
(STHCX gprc:$A, ForceXForm:$dst)>;
|
||||
(RLWINM (STHCX gprc:$A, ForceXForm:$dst), 31, 31, 31)>;
|
||||
def : Pat<(PPCStoreCond ForceXForm:$dst, gprc:$A, 2),
|
||||
(STHCX gprc:$A, ForceXForm:$dst)>;
|
||||
(RLWINM (STHCX gprc:$A, ForceXForm:$dst), 31, 31, 31)>;
|
||||
}
|
||||
def : Pat<(int_ppc_dcbtstt ForceXForm:$dst),
|
||||
(DCBTST 16, ForceXForm:$dst)>;
|
||||
|
|
|
|||
|
|
@ -314,57 +314,6 @@ void SparcAsmPrinter::printOperand(const MachineInstr *MI, int opNum,
|
|||
const MachineOperand &MO = MI->getOperand (opNum);
|
||||
SparcMCExpr::VariantKind TF = (SparcMCExpr::VariantKind) MO.getTargetFlags();
|
||||
|
||||
#ifndef NDEBUG
|
||||
// Verify the target flags.
|
||||
if (MO.isGlobal() || MO.isSymbol() || MO.isCPI()) {
|
||||
if (MI->getOpcode() == SP::CALL)
|
||||
assert(TF == SparcMCExpr::VK_Sparc_None &&
|
||||
"Cannot handle target flags on call address");
|
||||
else if (MI->getOpcode() == SP::SETHIi)
|
||||
assert((TF == SparcMCExpr::VK_Sparc_HI
|
||||
|| TF == SparcMCExpr::VK_Sparc_H44
|
||||
|| TF == SparcMCExpr::VK_Sparc_HH
|
||||
|| TF == SparcMCExpr::VK_Sparc_LM
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_GD_HI22
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_LDM_HI22
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_LDO_HIX22
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_IE_HI22
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_LE_HIX22) &&
|
||||
"Invalid target flags for address operand on sethi");
|
||||
else if (MI->getOpcode() == SP::TLS_CALL)
|
||||
assert((TF == SparcMCExpr::VK_Sparc_None
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_GD_CALL
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_LDM_CALL) &&
|
||||
"Cannot handle target flags on tls call address");
|
||||
else if (MI->getOpcode() == SP::TLS_ADDrr)
|
||||
assert((TF == SparcMCExpr::VK_Sparc_TLS_GD_ADD
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_LDM_ADD
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_LDO_ADD
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_IE_ADD) &&
|
||||
"Cannot handle target flags on add for TLS");
|
||||
else if (MI->getOpcode() == SP::TLS_LDrr)
|
||||
assert(TF == SparcMCExpr::VK_Sparc_TLS_IE_LD &&
|
||||
"Cannot handle target flags on ld for TLS");
|
||||
else if (MI->getOpcode() == SP::TLS_LDXrr)
|
||||
assert(TF == SparcMCExpr::VK_Sparc_TLS_IE_LDX &&
|
||||
"Cannot handle target flags on ldx for TLS");
|
||||
else if (MI->getOpcode() == SP::XORri)
|
||||
assert((TF == SparcMCExpr::VK_Sparc_TLS_LDO_LOX10
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_LE_LOX10) &&
|
||||
"Cannot handle target flags on xor for TLS");
|
||||
else
|
||||
assert((TF == SparcMCExpr::VK_Sparc_LO
|
||||
|| TF == SparcMCExpr::VK_Sparc_M44
|
||||
|| TF == SparcMCExpr::VK_Sparc_L44
|
||||
|| TF == SparcMCExpr::VK_Sparc_HM
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_GD_LO10
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_LDM_LO10
|
||||
|| TF == SparcMCExpr::VK_Sparc_TLS_IE_LO10 ) &&
|
||||
"Invalid target flags for small address operand");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
bool CloseParen = SparcMCExpr::printVariantKind(O, TF);
|
||||
|
||||
switch (MO.getType()) {
|
||||
|
|
|
|||
|
|
@ -1510,8 +1510,10 @@ def ICXWriteResGroup113 : SchedWriteRes<[ICXPort0,ICXPort49,ICXPort78,ICXPort015
|
|||
let ReleaseAtCycles = [1,8,8,2];
|
||||
}
|
||||
def: InstRW<[ICXWriteResGroup113], (instrs VPSCATTERDQZmr,
|
||||
VPSCATTERQDZmr,
|
||||
VPSCATTERQQZmr,
|
||||
VSCATTERDPDZmr,
|
||||
VSCATTERQPSZmr,
|
||||
VSCATTERQPDZmr)>;
|
||||
|
||||
def ICXWriteResGroup114 : SchedWriteRes<[ICXPort0,ICXPort49,ICXPort5,ICXPort78,ICXPort0156]> {
|
||||
|
|
|
|||
|
|
@ -1499,8 +1499,10 @@ def SKXWriteResGroup113 : SchedWriteRes<[SKXPort0,SKXPort4,SKXPort237,SKXPort015
|
|||
let ReleaseAtCycles = [1,8,8,2];
|
||||
}
|
||||
def: InstRW<[SKXWriteResGroup113], (instrs VPSCATTERDQZmr,
|
||||
VPSCATTERQDZmr,
|
||||
VPSCATTERQQZmr,
|
||||
VSCATTERDPDZmr,
|
||||
VSCATTERQPSZmr,
|
||||
VSCATTERQPDZmr)>;
|
||||
|
||||
def SKXWriteResGroup114 : SchedWriteRes<[SKXPort0,SKXPort4,SKXPort5,SKXPort237,SKXPort0156]> {
|
||||
|
|
|
|||
|
|
@ -1625,11 +1625,17 @@ void PGOUseFunc::setBranchWeights() {
|
|||
continue;
|
||||
|
||||
// We have a non-zero Branch BB.
|
||||
unsigned Size = BBCountInfo.OutEdges.size();
|
||||
SmallVector<uint64_t, 2> EdgeCounts(Size, 0);
|
||||
|
||||
// SuccessorCount can be greater than OutEdgesCount, because
|
||||
// removed edges don't appear in OutEdges.
|
||||
unsigned OutEdgesCount = BBCountInfo.OutEdges.size();
|
||||
unsigned SuccessorCount = BB.getTerminator()->getNumSuccessors();
|
||||
assert(OutEdgesCount <= SuccessorCount);
|
||||
|
||||
SmallVector<uint64_t, 2> EdgeCounts(SuccessorCount, 0);
|
||||
uint64_t MaxCount = 0;
|
||||
for (unsigned s = 0; s < Size; s++) {
|
||||
const PGOUseEdge *E = BBCountInfo.OutEdges[s];
|
||||
for (unsigned It = 0; It < OutEdgesCount; It++) {
|
||||
const PGOUseEdge *E = BBCountInfo.OutEdges[It];
|
||||
const BasicBlock *SrcBB = E->SrcBB;
|
||||
const BasicBlock *DestBB = E->DestBB;
|
||||
if (DestBB == nullptr)
|
||||
|
|
|
|||
|
|
@ -1464,7 +1464,7 @@ static bool checkAndReplaceCmp(CmpIntrinsic *I, ConstraintInfo &Info,
|
|||
ToRemove.push_back(I);
|
||||
return true;
|
||||
}
|
||||
if (checkCondition(ICmpInst::ICMP_EQ, LHS, RHS, I, Info)) {
|
||||
if (checkCondition(ICmpInst::ICMP_EQ, LHS, RHS, I, Info).value_or(false)) {
|
||||
I->replaceAllUsesWith(ConstantInt::get(I->getType(), 0));
|
||||
ToRemove.push_back(I);
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -1928,18 +1928,24 @@ Instruction *WidenIV::widenIVUse(WidenIV::NarrowIVDefUse DU,
|
|||
if (!WideAddRec.first)
|
||||
return nullptr;
|
||||
|
||||
// Reuse the IV increment that SCEVExpander created. Recompute flags, unless
|
||||
// the flags for both increments agree and it is safe to use the ones from
|
||||
// the original inc. In that case, the new use of the wide increment won't
|
||||
// be more poisonous.
|
||||
bool NeedToRecomputeFlags =
|
||||
!SCEVExpander::canReuseFlagsFromOriginalIVInc(OrigPhi, WidePhi,
|
||||
DU.NarrowUse, WideInc) ||
|
||||
DU.NarrowUse->hasNoUnsignedWrap() != WideInc->hasNoUnsignedWrap() ||
|
||||
DU.NarrowUse->hasNoSignedWrap() != WideInc->hasNoSignedWrap();
|
||||
auto CanUseWideInc = [&]() {
|
||||
if (!WideInc)
|
||||
return false;
|
||||
// Reuse the IV increment that SCEVExpander created. Recompute flags,
|
||||
// unless the flags for both increments agree and it is safe to use the
|
||||
// ones from the original inc. In that case, the new use of the wide
|
||||
// increment won't be more poisonous.
|
||||
bool NeedToRecomputeFlags =
|
||||
!SCEVExpander::canReuseFlagsFromOriginalIVInc(
|
||||
OrigPhi, WidePhi, DU.NarrowUse, WideInc) ||
|
||||
DU.NarrowUse->hasNoUnsignedWrap() != WideInc->hasNoUnsignedWrap() ||
|
||||
DU.NarrowUse->hasNoSignedWrap() != WideInc->hasNoSignedWrap();
|
||||
return WideAddRec.first == WideIncExpr &&
|
||||
Rewriter.hoistIVInc(WideInc, DU.NarrowUse, NeedToRecomputeFlags);
|
||||
};
|
||||
|
||||
Instruction *WideUse = nullptr;
|
||||
if (WideAddRec.first == WideIncExpr &&
|
||||
Rewriter.hoistIVInc(WideInc, DU.NarrowUse, NeedToRecomputeFlags))
|
||||
if (CanUseWideInc())
|
||||
WideUse = WideInc;
|
||||
else {
|
||||
WideUse = cloneIVUser(DU, WideAddRec.first);
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
#define LLVM_REVISION "llvmorg-19.1.0-rc3-0-g437434df21d8"
|
||||
#define LLVM_REVISION "llvmorg-19.1.0-rc4-0-g0c641568515a"
|
||||
#define LLVM_REPOSITORY "https://github.com/llvm/llvm-project.git"
|
||||
|
||||
#define CLANG_REVISION "llvmorg-19.1.0-rc3-0-g437434df21d8"
|
||||
#define CLANG_REVISION "llvmorg-19.1.0-rc4-0-g0c641568515a"
|
||||
#define CLANG_REPOSITORY "https://github.com/llvm/llvm-project.git"
|
||||
|
||||
#define LLDB_REVISION "llvmorg-19.1.0-rc3-0-g437434df21d8"
|
||||
#define LLDB_REVISION "llvmorg-19.1.0-rc4-0-g0c641568515a"
|
||||
#define LLDB_REPOSITORY "https://github.com/llvm/llvm-project.git"
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#define CLANG_VERSION 19.1.0-rc3
|
||||
#define CLANG_VERSION_STRING "19.1.0-rc3"
|
||||
#define CLANG_VERSION 19.1.0-rc4
|
||||
#define CLANG_VERSION_STRING "19.1.0-rc4"
|
||||
#define CLANG_VERSION_MAJOR 19
|
||||
#define CLANG_VERSION_MAJOR_STRING "19"
|
||||
#define CLANG_VERSION_MINOR 1
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
// Local identifier in __FreeBSD_version style
|
||||
#define LLD_FREEBSD_VERSION 1500001
|
||||
|
||||
#define LLD_VERSION_STRING "19.1.0 (FreeBSD llvmorg-19.1.0-rc3-0-g437434df21d8-" __XSTRING(LLD_FREEBSD_VERSION) ")"
|
||||
#define LLD_VERSION_STRING "19.1.0 (FreeBSD llvmorg-19.1.0-rc4-0-g0c641568515a-" __XSTRING(LLD_FREEBSD_VERSION) ")"
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#define LLDB_VERSION 19.1.0-rc3
|
||||
#define LLDB_VERSION_STRING "19.1.0-rc3"
|
||||
#define LLDB_VERSION 19.1.0-rc4
|
||||
#define LLDB_VERSION_STRING "19.1.0-rc4"
|
||||
#define LLDB_VERSION_MAJOR 19
|
||||
#define LLDB_VERSION_MINOR 1
|
||||
#define LLDB_VERSION_PATCH 0
|
||||
|
|
|
|||
|
|
@ -338,10 +338,10 @@
|
|||
#define PACKAGE_NAME "LLVM"
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#define PACKAGE_STRING "LLVM 19.1.0-rc3"
|
||||
#define PACKAGE_STRING "LLVM 19.1.0-rc4"
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#define PACKAGE_VERSION "19.1.0-rc3"
|
||||
#define PACKAGE_VERSION "19.1.0-rc4"
|
||||
|
||||
/* Define to the vendor of this package. */
|
||||
/* #undef PACKAGE_VENDOR */
|
||||
|
|
|
|||
|
|
@ -179,7 +179,7 @@
|
|||
#define LLVM_VERSION_PATCH 0
|
||||
|
||||
/* LLVM version string */
|
||||
#define LLVM_VERSION_STRING "19.1.0-rc3"
|
||||
#define LLVM_VERSION_STRING "19.1.0-rc4"
|
||||
|
||||
/* Whether LLVM records statistics for use with GetStatistics(),
|
||||
* PrintStatistics() or PrintStatisticsJSON()
|
||||
|
|
|
|||
|
|
@ -1,2 +1,2 @@
|
|||
#define LLVM_REVISION "llvmorg-19.1.0-rc3-0-g437434df21d8"
|
||||
#define LLVM_REVISION "llvmorg-19.1.0-rc4-0-g0c641568515a"
|
||||
#define LLVM_REPOSITORY "https://github.com/llvm/llvm-project.git"
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue