system/freebsd-src
system/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src synced 2024-07-21 18:27:22 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Merge llvm-project release/16.x llvmorg-16.0.5-0-g185b81e034ba

Browse source 
This updates llvm, clang, compiler-rt, libc++, libunwind, lld, lldb and
openmp to llvmorg-16.0.5-0-g185b81e034ba (aka 16.0.5 release).

PR:		271047
MFC after:	1 month
This commit is contained in:
Dimitry Andric 2023-06-04 21:01:35 +02:00
parent a324c34037 3b922bd951
commit 2efbaac7a0
26 changed files with 397 additions and 185 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
contrib/llvm-project/clang/include/clang/AST/ExprConcepts.h
View file

@ -64,6 +64,7 @@ class ConceptSpecializationExpr final : public Expr, public ConceptReference {
const ConstraintSatisfaction *Satisfaction);
ConceptSpecializationExpr(const ASTContext &C, ConceptDecl *NamedConcept,
const ASTTemplateArgumentListInfo *ArgsAsWritten,
ImplicitConceptSpecializationDecl *SpecDecl,
const ConstraintSatisfaction *Satisfaction,
bool Dependent,
@ -85,6 +86,13 @@ class ConceptSpecializationExpr final : public Expr, public ConceptReference {
const ConstraintSatisfaction *Satisfaction, bool Dependent,
bool ContainsUnexpandedParameterPack);
static ConceptSpecializationExpr *
Create(const ASTContext &C, ConceptDecl *NamedConcept,
const ASTTemplateArgumentListInfo *ArgsAsWritten,
ImplicitConceptSpecializationDecl *SpecDecl,
const ConstraintSatisfaction *Satisfaction, bool Dependent,
bool ContainsUnexpandedParameterPack);
ArrayRef<TemplateArgument> getTemplateArguments() const {
return SpecDecl->getTemplateArguments();
}

3
contrib/llvm-project/clang/include/clang/Basic/DiagnosticSemaKinds.td
View file

@ -2124,7 +2124,8 @@ def err_init_conversion_failed : Error<
"exception object|a member subobject|an array element|a new value|a value|a "
"base class|a constructor delegation|a vector element|a block element|a "
"block element|a complex element|a lambda capture|a compound literal "
"initializer|a related result|a parameter of CF audited function}0 "
"initializer|a related result|a parameter of CF audited function|a "
"structured binding|a member subobject}0 "
"%diff{of type $ with an %select{rvalue|lvalue}2 of type $|"
"with an %select{rvalue|lvalue}2 of incompatible type}1,3"
"%select{|: different classes%diff{ ($ vs $)|}5,6"

18
contrib/llvm-project/clang/include/clang/Sema/Initialization.h
View file

@ -123,6 +123,10 @@ class alignas(8) InitializedEntity {
/// decomposition declaration.
EK_Binding,
/// The entity being initialized is a non-static data member subobject of an
/// object initialized via parenthesized aggregate initialization.
EK_ParenAggInitMember,
// Note: err_init_conversion_failed in DiagnosticSemaKinds.td uses this
// enum as an index for its first %select. When modifying this list,
// that diagnostic text needs to be updated as well.
@ -227,8 +231,10 @@ class alignas(8) InitializedEntity {
/// Create the initialization entity for a member subobject.
InitializedEntity(FieldDecl *Member, const InitializedEntity *Parent,
bool Implicit, bool DefaultMemberInit)
: Kind(EK_Member), Parent(Parent), Type(Member->getType()),
bool Implicit, bool DefaultMemberInit,
bool IsParenAggInit = false)
: Kind(IsParenAggInit ? EK_ParenAggInitMember : EK_Member),
Parent(Parent), Type(Member->getType()),
Variable{Member, Implicit, DefaultMemberInit} {}
/// Create the initialization entity for an array element.
@ -388,6 +394,14 @@ class alignas(8) InitializedEntity {
return InitializedEntity(Member->getAnonField(), Parent, Implicit, false);
}
/// Create the initialization entity for a member subobject initialized via
/// parenthesized aggregate init.
static InitializedEntity InitializeMemberFromParenAggInit(FieldDecl *Member) {
return InitializedEntity(Member, /*Parent=*/nullptr, /*Implicit=*/false,
/*DefaultMemberInit=*/false,
/*IsParenAggInit=*/true);
}
/// Create the initialization entity for a default member initializer.
static InitializedEntity
InitializeMemberFromDefaultMemberInitializer(FieldDecl *Member) {

3
contrib/llvm-project/clang/lib/AST/ASTContext.cpp
View file

@ -765,7 +765,8 @@ canonicalizeImmediatelyDeclaredConstraint(const ASTContext &C, Expr *IDC,
CSE->getNamedConcept()->getLocation(), NewConverted);
Expr *NewIDC = ConceptSpecializationExpr::Create(
C, CSE->getNamedConcept(), CSD, nullptr, CSE->isInstantiationDependent(),
C, CSE->getNamedConcept(), CSE->getTemplateArgsAsWritten(), CSD,
/*Satisfaction=*/nullptr, CSE->isInstantiationDependent(),
CSE->containsUnexpandedParameterPack());
if (auto *OrigFold = dyn_cast<CXXFoldExpr>(IDC))

19
contrib/llvm-project/clang/lib/AST/ExprConcepts.cpp
View file

@ -58,6 +58,15 @@ ConceptSpecializationExpr::ConceptSpecializationExpr(
ConceptSpecializationExpr::ConceptSpecializationExpr(EmptyShell Empty)
: Expr(ConceptSpecializationExprClass, Empty) {}
ConceptSpecializationExpr *ConceptSpecializationExpr::Create(
const ASTContext &C, ConceptDecl *NamedConcept,
ImplicitConceptSpecializationDecl *SpecDecl,
const ConstraintSatisfaction *Satisfaction, bool Dependent,
bool ContainsUnexpandedParameterPack) {
return Create(C, NamedConcept, /*ArgsAsWritten*/ nullptr, SpecDecl, Satisfaction,
Dependent, ContainsUnexpandedParameterPack);
}
ConceptSpecializationExpr *ConceptSpecializationExpr::Create(
const ASTContext &C, NestedNameSpecifierLoc NNS,
SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
@ -72,13 +81,14 @@ ConceptSpecializationExpr *ConceptSpecializationExpr::Create(
ConceptSpecializationExpr::ConceptSpecializationExpr(
const ASTContext &C, ConceptDecl *NamedConcept,
const ASTTemplateArgumentListInfo *ArgsAsWritten,
ImplicitConceptSpecializationDecl *SpecDecl,
const ConstraintSatisfaction *Satisfaction, bool Dependent,
bool ContainsUnexpandedParameterPack)
: Expr(ConceptSpecializationExprClass, C.BoolTy, VK_PRValue, OK_Ordinary),
ConceptReference(NestedNameSpecifierLoc(), SourceLocation(),
DeclarationNameInfo(), NamedConcept, NamedConcept,
nullptr),
ArgsAsWritten),
SpecDecl(SpecDecl),
Satisfaction(Satisfaction
? ASTConstraintSatisfaction::Create(C, *Satisfaction)
@ -95,12 +105,13 @@ ConceptSpecializationExpr::ConceptSpecializationExpr(
ConceptSpecializationExpr *ConceptSpecializationExpr::Create(
const ASTContext &C, ConceptDecl *NamedConcept,
const ASTTemplateArgumentListInfo *ArgsAsWritten,
ImplicitConceptSpecializationDecl *SpecDecl,
const ConstraintSatisfaction *Satisfaction, bool Dependent,
bool ContainsUnexpandedParameterPack) {
return new (C)
ConceptSpecializationExpr(C, NamedConcept, SpecDecl, Satisfaction,
Dependent, ContainsUnexpandedParameterPack);
return new (C) ConceptSpecializationExpr(C, NamedConcept, ArgsAsWritten,
SpecDecl, Satisfaction, Dependent,
ContainsUnexpandedParameterPack);
}
const TypeConstraint *

1
contrib/llvm-project/clang/lib/Driver/ToolChains/Clang.cpp
View file

@ -7801,6 +7801,7 @@ void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType,
} else {
D.Diag(diag::err_drv_invalid_value) << A->getSpelling() << GuardArgs;
}
A->claim();
}
}

6
contrib/llvm-project/clang/lib/Format/IntegerLiteralSeparatorFixer.cpp
View file

@ -113,7 +113,11 @@ IntegerLiteralSeparatorFixer::process(const Environment &Env,
continue;
}
if (Style.isCpp()) {
if (const auto Pos = Text.find_first_of("_i"); Pos != StringRef::npos) {
// Hex alpha digits a-f/A-F must be at the end of the string literal.
StringRef Suffixes = "_himnsuyd";
if (const auto Pos =
Text.find_first_of(IsBase16 ? Suffixes.drop_back() : Suffixes);
Pos != StringRef::npos) {
Text = Text.substr(0, Pos);
Length = Pos;
}

3
contrib/llvm-project/clang/lib/Sema/SemaAccess.cpp
View file

@ -1651,7 +1651,8 @@ Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc,
<< Entity.getBaseSpecifier()->getType() << getSpecialMember(Constructor);
break;
case InitializedEntity::EK_Member: {
case InitializedEntity::EK_Member:
case InitializedEntity::EK_ParenAggInitMember: {
const FieldDecl *Field = cast<FieldDecl>(Entity.getDecl());
PD = PDiag(diag::err_access_field_ctor);
PD << Field->getType() << getSpecialMember(Constructor);

2
contrib/llvm-project/clang/lib/Sema/SemaDecl.cpp
View file

@ -8693,7 +8693,7 @@ void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
}
// Check that SVE types are only used in functions with SVE available.
if (T->isSVESizelessBuiltinType() && CurContext->isFunctionOrMethod()) {
if (T->isSVESizelessBuiltinType() && isa<FunctionDecl>(CurContext)) {
const FunctionDecl *FD = cast<FunctionDecl>(CurContext);
llvm::StringMap<bool> CallerFeatureMap;
Context.getFunctionFeatureMap(CallerFeatureMap, FD);

335
contrib/llvm-project/clang/lib/Sema/SemaInit.cpp
View file

@ -1152,6 +1152,7 @@ static void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity,
case InitializedEntity::EK_Parameter_CF_Audited:
case InitializedEntity::EK_TemplateParameter:
case InitializedEntity::EK_Result:
case InitializedEntity::EK_ParenAggInitMember:
// Extra braces here are suspicious.
DiagID = diag::warn_braces_around_init;
break;
@ -3348,6 +3349,7 @@ DeclarationName InitializedEntity::getName() const {
case EK_Variable:
case EK_Member:
case EK_ParenAggInitMember:
case EK_Binding:
case EK_TemplateParameter:
return Variable.VariableOrMember->getDeclName();
@ -3379,6 +3381,7 @@ ValueDecl *InitializedEntity::getDecl() const {
switch (getKind()) {
case EK_Variable:
case EK_Member:
case EK_ParenAggInitMember:
case EK_Binding:
case EK_TemplateParameter:
return Variable.VariableOrMember;
@ -3420,6 +3423,7 @@ bool InitializedEntity::allowsNRVO() const {
case EK_Parameter_CF_Audited:
case EK_TemplateParameter:
case EK_Member:
case EK_ParenAggInitMember:
case EK_Binding:
case EK_New:
case EK_Temporary:
@ -3454,7 +3458,10 @@ unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
case EK_Result: OS << "Result"; break;
case EK_StmtExprResult: OS << "StmtExprResult"; break;
case EK_Exception: OS << "Exception"; break;
case EK_Member: OS << "Member"; break;
case EK_Member:
case EK_ParenAggInitMember:
OS << "Member";
break;
case EK_Binding: OS << "Binding"; break;
case EK_New: OS << "New"; break;
case EK_Temporary: OS << "Temporary"; break;
@ -5274,179 +5281,224 @@ static void TryOrBuildParenListInitialization(
Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind,
ArrayRef<Expr *> Args, InitializationSequence &Sequence, bool VerifyOnly,
ExprResult *Result = nullptr) {
unsigned ArgIndexToProcess = 0;
unsigned EntityIndexToProcess = 0;
SmallVector<Expr *, 4> InitExprs;
QualType ResultType;
Expr *ArrayFiller = nullptr;
FieldDecl *InitializedFieldInUnion = nullptr;
// Process entities (i.e. array members, base classes, or class fields) by
// adding an initialization expression to InitExprs for each entity to
// initialize.
auto ProcessEntities = [&](auto Range) -> bool {
bool IsUnionType = Entity.getType()->isUnionType();
for (InitializedEntity SubEntity : Range) {
// Unions should only have one initializer expression.
// If there are more initializers than it will be caught when we check
// whether Index equals Args.size().
if (ArgIndexToProcess == 1 && IsUnionType)
return true;
auto HandleInitializedEntity = [&](const InitializedEntity &SubEntity,
const InitializationKind &SubKind,
Expr *Arg, Expr **InitExpr = nullptr) {
InitializationSequence IS = [&]() {
if (Arg)
return InitializationSequence(S, SubEntity, SubKind, Arg);
return InitializationSequence(S, SubEntity, SubKind, std::nullopt);
}();
bool IsMember = SubEntity.getKind() == InitializedEntity::EK_Member;
// Unnamed bitfields should not be initialized at all, either with an arg
// or by default.
if (IsMember && cast<FieldDecl>(SubEntity.getDecl())->isUnnamedBitfield())
continue;
if (ArgIndexToProcess < Args.size()) {
// There are still expressions in Args that haven't been processed.
// Let's match them to the current entity to initialize.
Expr *E = Args[ArgIndexToProcess++];
// Incomplete array types indicate flexible array members. Do not allow
// paren list initializations of structs with these members, as GCC
// doesn't either.
if (IsMember) {
auto *FD = cast<FieldDecl>(SubEntity.getDecl());
if (FD->getType()->isIncompleteArrayType()) {
if (!VerifyOnly) {
S.Diag(E->getBeginLoc(), diag::err_flexible_array_init)
<< SourceRange(E->getBeginLoc(), E->getEndLoc());
S.Diag(FD->getLocation(), diag::note_flexible_array_member) << FD;
}
Sequence.SetFailed(
InitializationSequence::FK_ParenthesizedListInitFailed);
return false;
}
}
InitializationKind SubKind = InitializationKind::CreateForInit(
E->getExprLoc(), /*isDirectInit=*/false, E);
InitializationSequence SubSeq(S, SubEntity, SubKind, E);
if (SubSeq.Failed()) {
if (!VerifyOnly)
SubSeq.Diagnose(S, SubEntity, SubKind, E);
else
Sequence.SetFailed(
InitializationSequence::FK_ParenthesizedListInitFailed);
return false;
}
if (!VerifyOnly) {
ExprResult ER = SubSeq.Perform(S, SubEntity, SubKind, E);
InitExprs.push_back(ER.get());
if (IsMember && IsUnionType)
InitializedFieldInUnion = cast<FieldDecl>(SubEntity.getDecl());
}
if (IS.Failed()) {
if (!VerifyOnly) {
if (Arg)
IS.Diagnose(S, SubEntity, SubKind, Arg);
else
IS.Diagnose(S, SubEntity, SubKind, std::nullopt);
} else {
// We've processed all of the args, but there are still entities that
// have to be initialized.
if (IsMember) {
// C++ [dcl.init]p17.6.2.2
// The remaining elements are initialized with their default member
// initializers, if any
auto *FD = cast<FieldDecl>(SubEntity.getDecl());
if (FD->hasInClassInitializer()) {
if (!VerifyOnly) {
ExprResult DIE = S.BuildCXXDefaultInitExpr(FD->getLocation(), FD);
if (DIE.isInvalid())
return false;
S.checkInitializerLifetime(SubEntity, DIE.get());
InitExprs.push_back(DIE.get());
}
continue;
}
}
// Remaining class elements without default member initializers and
// array elements are value initialized:
//
// C++ [dcl.init]p17.6.2.2
// The remaining elements...otherwise are value initialzed
//
// C++ [dcl.init]p17.5
// if the destination type is an array, the object is initialized as
// . follows. Let x1, . . . , xk be the elements of the expression-list
// ...Let n denote the array size...the ith array element is...value-
// initialized for each k < i <= n.
InitializationKind SubKind = InitializationKind::CreateValue(
Kind.getLocation(), Kind.getLocation(), Kind.getLocation(), true);
InitializationSequence SubSeq(S, SubEntity, SubKind, std::nullopt);
if (SubSeq.Failed()) {
if (!VerifyOnly)
SubSeq.Diagnose(S, SubEntity, SubKind, std::nullopt);
return false;
}
if (!VerifyOnly) {
ExprResult ER = SubSeq.Perform(S, SubEntity, SubKind, std::nullopt);
if (SubEntity.getKind() == InitializedEntity::EK_ArrayElement) {
ArrayFiller = ER.get();
return true;
}
InitExprs.push_back(ER.get());
}
Sequence.SetFailed(
InitializationSequence::FK_ParenthesizedListInitFailed);
}
return false;
}
if (!VerifyOnly) {
ExprResult ER;
if (Arg)
ER = IS.Perform(S, SubEntity, SubKind, Arg);
else
ER = IS.Perform(S, SubEntity, SubKind, std::nullopt);
if (InitExpr)
*InitExpr = ER.get();
else
InitExprs.push_back(ER.get());
}
return true;
};
if (const ArrayType *AT =
S.getASTContext().getAsArrayType(Entity.getType())) {
SmallVector<InitializedEntity, 4> ElementEntities;
uint64_t ArrayLength;
// C++ [dcl.init]p17.5
// C++ [dcl.init]p16.5
// if the destination type is an array, the object is initialized as
// follows. Let x1, . . . , xk be the elements of the expression-list. If
// the destination type is an array of unknown bound, it is define as
// the destination type is an array of unknown bound, it is defined as
// having k elements.
if (const ConstantArrayType *CAT =
S.getASTContext().getAsConstantArrayType(Entity.getType()))
S.getASTContext().getAsConstantArrayType(Entity.getType())) {
ArrayLength = CAT->getSize().getZExtValue();
else
ResultType = Entity.getType();
} else if (const VariableArrayType *VAT =
S.getASTContext().getAsVariableArrayType(Entity.getType())) {
// Braced-initialization of variable array types is not allowed, even if
// the size is greater than or equal to the number of args, so we don't
// allow them to be initialized via parenthesized aggregate initialization
// either.
const Expr *SE = VAT->getSizeExpr();
S.Diag(SE->getBeginLoc(), diag::err_variable_object_no_init)
<< SE->getSourceRange();
return;
} else {
assert(isa<IncompleteArrayType>(Entity.getType()));
ArrayLength = Args.size();
}
EntityIndexToProcess = ArrayLength;
if (ArrayLength >= Args.size()) {
for (uint64_t I = 0; I < ArrayLength; ++I)
ElementEntities.push_back(
InitializedEntity::InitializeElement(S.getASTContext(), I, Entity));
if (!ProcessEntities(ElementEntities))
// ...the ith array element is copy-initialized with xi for each
// 1 <= i <= k
for (Expr *E : Args) {
InitializedEntity SubEntity = InitializedEntity::InitializeElement(
S.getASTContext(), EntityIndexToProcess, Entity);
InitializationKind SubKind = InitializationKind::CreateForInit(
E->getExprLoc(), /*isDirectInit=*/false, E);
if (!HandleInitializedEntity(SubEntity, SubKind, E))
return;
}
// ...and value-initialized for each k < i <= n;
if (ArrayLength > Args.size()) {
InitializedEntity SubEntity = InitializedEntity::InitializeElement(
S.getASTContext(), Args.size(), Entity);
InitializationKind SubKind = InitializationKind::CreateValue(
Kind.getLocation(), Kind.getLocation(), Kind.getLocation(), true);
if (!HandleInitializedEntity(SubEntity, SubKind, nullptr, &ArrayFiller))
return;
}
if (ResultType.isNull()) {
ResultType = S.Context.getConstantArrayType(
AT->getElementType(), llvm::APInt(/*numBits=*/32, ArrayLength),
nullptr, ArrayType::Normal, 0);
/*SizeExpr=*/nullptr, ArrayType::Normal, 0);
}
} else if (auto *RT = Entity.getType()->getAs<RecordType>()) {
bool IsUnion = RT->isUnionType();
const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
auto BaseRange = map_range(RD->bases(), [&](auto &base) {
return InitializedEntity::InitializeBase(S.getASTContext(), &base, false,
&Entity);
});
auto FieldRange = map_range(RD->fields(), [](auto *field) {
return InitializedEntity::InitializeMember(field);
});
if (!IsUnion) {
for (const CXXBaseSpecifier &Base : RD->bases()) {
InitializedEntity SubEntity = InitializedEntity::InitializeBase(
S.getASTContext(), &Base, false, &Entity);
if (EntityIndexToProcess < Args.size()) {
// C++ [dcl.init]p16.6.2.2.
// ...the object is initialized is follows. Let e1, ..., en be the
// elements of the aggregate([dcl.init.aggr]). Let x1, ..., xk be
// the elements of the expression-list...The element ei is
// copy-initialized with xi for 1 <= i <= k.
Expr *E = Args[EntityIndexToProcess];
InitializationKind SubKind = InitializationKind::CreateForInit(
E->getExprLoc(), /*isDirectInit=*/false, E);
if (!HandleInitializedEntity(SubEntity, SubKind, E))
return;
} else {
// We've processed all of the args, but there are still base classes
// that have to be initialized.
// C++ [dcl.init]p17.6.2.2
// The remaining elements...otherwise are value initialzed
InitializationKind SubKind = InitializationKind::CreateValue(
Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
/*IsImplicit=*/true);
if (!HandleInitializedEntity(SubEntity, SubKind, nullptr))
return;
}
EntityIndexToProcess++;
}
}
if (!ProcessEntities(BaseRange))
return;
for (FieldDecl *FD : RD->fields()) {
// Unnamed bitfields should not be initialized at all, either with an arg
// or by default.
if (FD->isUnnamedBitfield())
continue;
if (!ProcessEntities(FieldRange))
return;
InitializedEntity SubEntity =
InitializedEntity::InitializeMemberFromParenAggInit(FD);
if (EntityIndexToProcess < Args.size()) {
// ...The element ei is copy-initialized with xi for 1 <= i <= k.
Expr *E = Args[EntityIndexToProcess];
// Incomplete array types indicate flexible array members. Do not allow
// paren list initializations of structs with these members, as GCC
// doesn't either.
if (FD->getType()->isIncompleteArrayType()) {
if (!VerifyOnly) {
S.Diag(E->getBeginLoc(), diag::err_flexible_array_init)
<< SourceRange(E->getBeginLoc(), E->getEndLoc());
S.Diag(FD->getLocation(), diag::note_flexible_array_member) << FD;
}
Sequence.SetFailed(
InitializationSequence::FK_ParenthesizedListInitFailed);
return;
}
InitializationKind SubKind = InitializationKind::CreateForInit(
E->getExprLoc(), /*isDirectInit=*/false, E);
if (!HandleInitializedEntity(SubEntity, SubKind, E))
return;
// Unions should have only one initializer expression, so we bail out
// after processing the first field. If there are more initializers then
// it will be caught when we later check whether EntityIndexToProcess is
// less than Args.size();
if (IsUnion) {
InitializedFieldInUnion = FD;
EntityIndexToProcess = 1;
break;
}
} else {
// We've processed all of the args, but there are still members that
// have to be initialized.
if (FD->hasInClassInitializer()) {
if (!VerifyOnly) {
// C++ [dcl.init]p16.6.2.2
// The remaining elements are initialized with their default
// member initializers, if any
ExprResult DIE = S.BuildCXXDefaultInitExpr(FD->getLocation(), FD);
if (DIE.isInvalid())
return;
S.checkInitializerLifetime(SubEntity, DIE.get());
InitExprs.push_back(DIE.get());
}
} else {
// C++ [dcl.init]p17.6.2.2
// The remaining elements...otherwise are value initialzed
if (FD->getType()->isReferenceType()) {
Sequence.SetFailed(
InitializationSequence::FK_ParenthesizedListInitFailed);
if (!VerifyOnly) {
SourceRange SR = Kind.getParenOrBraceRange();
S.Diag(SR.getEnd(), diag::err_init_reference_member_uninitialized)
<< FD->getType() << SR;
S.Diag(FD->getLocation(), diag::note_uninit_reference_member);
}
return;
}
InitializationKind SubKind = InitializationKind::CreateValue(
Kind.getLocation(), Kind.getLocation(), Kind.getLocation(), true);
if (!HandleInitializedEntity(SubEntity, SubKind, nullptr))
return;
}
}
EntityIndexToProcess++;
}
ResultType = Entity.getType();
}
// Not all of the args have been processed, so there must've been more args
// then were required to initialize the element.
if (ArgIndexToProcess < Args.size()) {
// than were required to initialize the element.
if (EntityIndexToProcess < Args.size()) {
Sequence.SetFailed(InitializationSequence::FK_ParenthesizedListInitFailed);
if (!VerifyOnly) {
QualType T = Entity.getType();
int InitKind = T->isArrayType() ? 0 : T->isUnionType() ? 3 : 4;
SourceRange ExcessInitSR(Args[ArgIndexToProcess]->getBeginLoc(),
SourceRange ExcessInitSR(Args[EntityIndexToProcess]->getBeginLoc(),
Args.back()->getEndLoc());
S.Diag(Kind.getLocation(), diag::err_excess_initializers)
<< InitKind << ExcessInitSR;
@ -6412,6 +6464,7 @@ getAssignmentAction(const InitializedEntity &Entity, bool Diagnose = false) {
return Sema::AA_Converting;
case InitializedEntity::EK_Member:
case InitializedEntity::EK_ParenAggInitMember:
case InitializedEntity::EK_Binding:
case InitializedEntity::EK_ArrayElement:
case InitializedEntity::EK_VectorElement:
@ -6432,6 +6485,7 @@ static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
switch (Entity.getKind()) {
case InitializedEntity::EK_ArrayElement:
case InitializedEntity::EK_Member:
case InitializedEntity::EK_ParenAggInitMember:
case InitializedEntity::EK_Result:
case InitializedEntity::EK_StmtExprResult:
case InitializedEntity::EK_New:
@ -6476,6 +6530,7 @@ static bool shouldDestroyEntity(const InitializedEntity &Entity) {
return false;
case InitializedEntity::EK_Member:
case InitializedEntity::EK_ParenAggInitMember:
case InitializedEntity::EK_Binding:
case InitializedEntity::EK_Variable:
case InitializedEntity::EK_Parameter:
@ -6512,6 +6567,7 @@ static SourceLocation getInitializationLoc(const InitializedEntity &Entity,
case InitializedEntity::EK_ArrayElement:
case InitializedEntity::EK_Member:
case InitializedEntity::EK_ParenAggInitMember:
case InitializedEntity::EK_Parameter:
case InitializedEntity::EK_Parameter_CF_Audited:
case InitializedEntity::EK_TemplateParameter:
@ -7080,7 +7136,15 @@ static LifetimeResult getEntityLifetime(
case InitializedEntity::EK_Exception:
// FIXME: Can we diagnose lifetime problems with exceptions?
return {nullptr, LK_FullExpression};
case InitializedEntity::EK_ParenAggInitMember:
// -- A temporary object bound to a reference element of an aggregate of
// class type initialized from a parenthesized expression-list
// [dcl.init, 9.3] persists until the completion of the full-expression
// containing the expression-list.
return {nullptr, LK_FullExpression};
}
llvm_unreachable("unknown entity kind");
}
@ -9196,7 +9260,9 @@ ExprResult InitializationSequence::Perform(Sema &S,
S.checkInitializerLifetime(Entity, Init);
// Diagnose non-fatal problems with the completed initialization.
if (Entity.getKind() == InitializedEntity::EK_Member &&
if (InitializedEntity::EntityKind EK = Entity.getKind();
(EK == InitializedEntity::EK_Member ||
EK == InitializedEntity::EK_ParenAggInitMember) &&
cast<FieldDecl>(Entity.getDecl())->isBitField())
S.CheckBitFieldInitialization(Kind.getLocation(),
cast<FieldDecl>(Entity.getDecl()),
@ -9650,7 +9716,8 @@ bool InitializationSequence::Diagnose(Sema &S,
case OR_No_Viable_Function:
if (Kind.getKind() == InitializationKind::IK_Default &&
(Entity.getKind() == InitializedEntity::EK_Base ||
Entity.getKind() == InitializedEntity::EK_Member) &&
Entity.getKind() == InitializedEntity::EK_Member ||
Entity.getKind() == InitializedEntity::EK_ParenAggInitMember) &&
isa<CXXConstructorDecl>(S.CurContext)) {
// This is implicit default initialization of a member or
// base within a constructor. If no viable function was

2
contrib/llvm-project/libcxx/include/__config
View file

@ -38,7 +38,7 @@
// _LIBCPP_VERSION represents the version of libc++, which matches the version of LLVM.
// Given a LLVM release LLVM XX.YY.ZZ (e.g. LLVM 16.0.1 == 16.00.01), _LIBCPP_VERSION is
// defined to XXYYZZ.
# define _LIBCPP_VERSION 160004
# define _LIBCPP_VERSION 160005
# define _LIBCPP_CONCAT_IMPL(_X, _Y) _X##_Y
# define _LIBCPP_CONCAT(_X, _Y) _LIBCPP_CONCAT_IMPL(_X, _Y)

33
contrib/llvm-project/lld/docs/WebAssembly.rst
View file

@ -75,6 +75,11 @@ WebAssembly-specific options:
flag which corresponds to ``--unresolve-symbols=ignore`` +
``--import-undefined``.
.. option:: --allow-undefined-file=<filename>
Like ``--allow-undefined``, but the filename specified a flat list of
symbols, one per line, which are allowed to be undefined.
.. option:: --unresolved-symbols=<method>
This is a more full featured version of ``--allow-undefined``.
@ -182,11 +187,39 @@ Imports
By default no undefined symbols are allowed in the final binary. The flag
``--allow-undefined`` results in a WebAssembly import being defined for each
undefined symbol. It is then up to the runtime to provide such symbols.
``--allow-undefined-file`` is the same but allows a list of symbols to be
specified.
Alternatively symbols can be marked in the source code as with the
``import_name`` and/or ``import_module`` clang attributes which signals that
they are expected to be undefined at static link time.
Stub Libraries
~~~~~~~~~~~~~~
Another way to specify imports and exports is via a "stub library". This
feature is inspired by the ELF stub objects which are supported by the Solaris
linker. Stub libraries are text files that can be passed as normal linker
inputs, similar to how linker scripts can be passed to the ELF linker. The stub
library is a stand-in for a set of symbols that will be available at runtime,
but doesn't contain any actual code or data. Instead it contains just a list of
symbols, one per line. Each symbol can specify zero or more dependencies.
These dependencies are symbols that must be defined, and exported, by the output
module if the symbol is question is imported/required by the output module.
For example, imagine the runtime provides an external symbol ``foo`` that
depends on the ``malloc`` and ``free``. This can be expressed simply as::
#STUB
foo: malloc,free
Here we are saying that ``foo`` is allowed to be imported (undefined) but that
if it is imported, then the output module must also export ``malloc`` and
``free`` to the runtime. If ``foo`` is imported (undefined), but the output
module does not define ``malloc`` and ``free`` then the link will fail.
Stub libraries must begin with ``#STUB`` on a line by itself.
Garbage Collection
~~~~~~~~~~~~~~~~~~

9
contrib/llvm-project/llvm/include/llvm/Analysis/AliasAnalysis.h
View file

@ -116,6 +116,15 @@ class AliasResult {
operator Kind() const { return static_cast<Kind>(Alias); }
bool operator==(const AliasResult &Other) const {
return Alias == Other.Alias && HasOffset == Other.HasOffset &&
Offset == Other.Offset;
}
bool operator!=(const AliasResult &Other) const { return !(*this == Other); }
bool operator==(Kind K) const { return Alias == K; }
bool operator!=(Kind K) const { return !(*this == K); }
constexpr bool hasOffset() const { return HasOffset; }
constexpr int32_t getOffset() const {
assert(HasOffset && "No offset!");

12
contrib/llvm-project/llvm/include/llvm/Analysis/TargetLibraryInfo.h
View file

@ -408,14 +408,14 @@ class TargetLibraryInfo {
ShouldExtI32Param = true;
ShouldExtI32Return = true;
}
// Mips and riscv64, on the other hand, needs signext on i32 parameters
// corresponding to both signed and unsigned ints.
if (T.isMIPS() || T.isRISCV64()) {
// LoongArch, Mips, and riscv64, on the other hand, need signext on i32
// parameters corresponding to both signed and unsigned ints.
if (T.isLoongArch() || T.isMIPS() || T.isRISCV64()) {
ShouldSignExtI32Param = true;
}
// riscv64 needs signext on i32 returns corresponding to both signed and
// unsigned ints.
if (T.isRISCV64()) {
// LoongArch and riscv64 need signext on i32 returns corresponding to both
// signed and unsigned ints.
if (T.isLoongArch() || T.isRISCV64()) {
ShouldSignExtI32Return = true;
}
}

7
contrib/llvm-project/llvm/lib/Target/Hexagon/HexagonISelLowering.cpp
View file

@ -1628,7 +1628,7 @@ HexagonTargetLowering::HexagonTargetLowering(const TargetMachine &TM,
ISD::UADDO, ISD::SSUBO, ISD::USUBO, ISD::SMUL_LOHI, ISD::UMUL_LOHI,
// Logical/bit:
ISD::AND, ISD::OR, ISD::XOR, ISD::ROTL, ISD::ROTR,
ISD::CTPOP, ISD::CTLZ, ISD::CTTZ,
ISD::CTPOP, ISD::CTLZ, ISD::CTTZ, ISD::BSWAP, ISD::BITREVERSE,
// Floating point arithmetic/math functions:
ISD::FADD, ISD::FSUB, ISD::FMUL, ISD::FMA, ISD::FDIV,
ISD::FREM, ISD::FNEG, ISD::FABS, ISD::FSQRT, ISD::FSIN,
@ -1701,8 +1701,11 @@ HexagonTargetLowering::HexagonTargetLowering(const TargetMachine &TM,
setOperationAction(ISD::OR, NativeVT, Legal);
setOperationAction(ISD::XOR, NativeVT, Legal);
if (NativeVT.getVectorElementType() != MVT::i1)
if (NativeVT.getVectorElementType() != MVT::i1) {
setOperationAction(ISD::SPLAT_VECTOR, NativeVT, Legal);
setOperationAction(ISD::BSWAP, NativeVT, Legal);
setOperationAction(ISD::BITREVERSE, NativeVT, Legal);
}
}
for (MVT VT : {MVT::v8i8, MVT::v4i16, MVT::v2i32}) {

24
contrib/llvm-project/llvm/lib/Target/Hexagon/HexagonPatterns.td
View file

@ -117,8 +117,8 @@ def usat: PatFrag<(ops node:$V, node:$Ty), (HexagonUSAT node:$V, node:$Ty)>;
// Pattern fragments to extract the low and high subregisters from a
// 64-bit value.
def LoReg: OutPatFrag<(ops node:$Rs), (EXTRACT_SUBREG (i64 $Rs), isub_lo)>;
def HiReg: OutPatFrag<(ops node:$Rs), (EXTRACT_SUBREG (i64 $Rs), isub_hi)>;
def LoReg: OutPatFrag<(ops node:$Rs), (EXTRACT_SUBREG $Rs, isub_lo)>;
def HiReg: OutPatFrag<(ops node:$Rs), (EXTRACT_SUBREG $Rs, isub_hi)>;
def IsOrAdd: PatFrag<(ops node:$A, node:$B), (or node:$A, node:$B), [{
return isOrEquivalentToAdd(N);
@ -1123,6 +1123,12 @@ def: Pat<(bswap I32:$Rs), (A2_swiz I32:$Rs)>;
def: Pat<(bswap I64:$Rss), (Combinew (A2_swiz (LoReg $Rss)),
(A2_swiz (HiReg $Rss)))>;
def: Pat<(bswap V2I16:$Rs), (A2_combine_lh (A2_swiz $Rs), (A2_swiz $Rs))>;
def: Pat<(bswap V2I32:$Rs), (Combinew (A2_swiz (HiReg $Rs)),
(A2_swiz (LoReg $Rs)))>;
def: Pat<(bswap V4I16:$Rs), (A2_orp (S2_lsr_i_vh $Rs, 8),
(S2_asl_i_vh $Rs, 8))>;
def: Pat<(shl s6_0ImmPred:$s6, I32:$Rt), (S4_lsli imm:$s6, I32:$Rt)>;
def: Pat<(shl I32:$Rs, (i32 16)), (A2_aslh I32:$Rs)>;
def: Pat<(sra I32:$Rs, (i32 16)), (A2_asrh I32:$Rs)>;
@ -1854,6 +1860,20 @@ def: Pat<(i32 (ctpop I32:$Rs)), (S5_popcountp (A4_combineir 0, I32:$Rs))>;
def: Pat<(bitreverse I32:$Rs), (S2_brev I32:$Rs)>;
def: Pat<(bitreverse I64:$Rss), (S2_brevp I64:$Rss)>;
def: Pat<(bitreverse V4I8:$Rs), (A2_swiz (S2_brev $Rs))>;
def: Pat<(bitreverse V8I8:$Rs), (Combinew (A2_swiz (LoReg (S2_brevp $Rs))),
(A2_swiz (HiReg (S2_brevp $Rs))))>;
def: Pat<(bitreverse V2I16:$Rs), (A2_combine_lh (S2_brev $Rs),
(S2_brev $Rs))>;
def: Pat<(bitreverse V4I16:$Rs),
(Combinew (A2_combine_lh (LoReg (S2_brevp $Rs)),
(LoReg (S2_brevp $Rs))),
(A2_combine_lh (HiReg (S2_brevp $Rs)),
(HiReg (S2_brevp $Rs))))>;
def: Pat<(bitreverse V2I32:$Rs),
(Combinew (i32 (LoReg (S2_brevp $Rs))),
(i32 (HiReg (S2_brevp $Rs))))>;
let AddedComplexity = 20 in { // Complexity greater than and/or/xor
def: Pat<(and I32:$Rs, IsNPow2_32:$V),
(S2_clrbit_i IntRegs:$Rs, (LogN2_32 $V))>;

27
contrib/llvm-project/llvm/lib/Target/X86/X86ISelLowering.cpp
View file

@ -499,7 +499,7 @@ X86TargetLowering::X86TargetLowering(const X86TargetMachine &TM,
}
if (Subtarget.hasSSEPrefetch() || Subtarget.hasThreeDNow())
setOperationAction(ISD::PREFETCH , MVT::Other, Legal);
setOperationAction(ISD::PREFETCH , MVT::Other, Custom);
setOperationAction(ISD::ATOMIC_FENCE , MVT::Other, Custom);
@ -2195,6 +2195,7 @@ X86TargetLowering::X86TargetLowering(const X86TargetMachine &TM,
setOperationAction(ISD::FMUL, VT, Expand);
setOperationAction(ISD::FDIV, VT, Expand);
setOperationAction(ISD::BUILD_VECTOR, VT, Custom);
setOperationAction(ISD::VECTOR_SHUFFLE, VT, Custom);
}
addLegalFPImmediate(APFloat::getZero(APFloat::BFloat()));
}
@ -2207,6 +2208,7 @@ X86TargetLowering::X86TargetLowering(const X86TargetMachine &TM,
setOperationAction(ISD::FMUL, MVT::v32bf16, Expand);
setOperationAction(ISD::FDIV, MVT::v32bf16, Expand);
setOperationAction(ISD::BUILD_VECTOR, MVT::v32bf16, Custom);
setOperationAction(ISD::VECTOR_SHUFFLE, MVT::v32bf16, Custom);
}
if (!Subtarget.useSoftFloat() && Subtarget.hasVLX()) {
@ -18773,11 +18775,11 @@ static SDValue lower256BitShuffle(const SDLoc &DL, ArrayRef<int> Mask, MVT VT,
return DAG.getBitcast(VT, DAG.getVectorShuffle(FpVT, DL, V1, V2, Mask));
}
if (VT == MVT::v16f16) {
V1 = DAG.getBitcast(MVT::v16i16, V1);
V2 = DAG.getBitcast(MVT::v16i16, V2);
return DAG.getBitcast(MVT::v16f16,
DAG.getVectorShuffle(MVT::v16i16, DL, V1, V2, Mask));
if (VT == MVT::v16f16 || VT.getVectorElementType() == MVT::bf16) {
MVT IVT = VT.changeVectorElementTypeToInteger();
V1 = DAG.getBitcast(IVT, V1);
V2 = DAG.getBitcast(IVT, V2);
return DAG.getBitcast(VT, DAG.getVectorShuffle(IVT, DL, V1, V2, Mask));
}
switch (VT.SimpleTy) {
@ -33093,6 +33095,18 @@ static SDValue LowerCVTPS2PH(SDValue Op, SelectionDAG &DAG) {
return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Lo, Hi);
}
static SDValue LowerPREFETCH(SDValue Op, const X86Subtarget &Subtarget,
SelectionDAG &DAG) {
unsigned IsData = cast<ConstantSDNode>(Op.getOperand(4))->getZExtValue();
// We don't support non-data prefetch without PREFETCHI.
// Just preserve the chain.
if (!IsData && !Subtarget.hasPREFETCHI())
return Op.getOperand(0);
return Op;
}
static StringRef getInstrStrFromOpNo(const SmallVectorImpl<StringRef> &AsmStrs,
unsigned OpNo) {
const APInt Operand(32, OpNo);
@ -33294,6 +33308,7 @@ SDValue X86TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
case ISD::GC_TRANSITION_END: return LowerGC_TRANSITION(Op, DAG);
case ISD::ADDRSPACECAST: return LowerADDRSPACECAST(Op, DAG);
case X86ISD::CVTPS2PH: return LowerCVTPS2PH(Op, DAG);
case ISD::PREFETCH: return LowerPREFETCH(Op, Subtarget, DAG);
}
}

21
contrib/llvm-project/llvm/lib/Target/X86/X86InstrAVX512.td
View file

@ -12969,6 +12969,27 @@ let Predicates = [HasBF16, HasVLX] in {
(VCVTNEPS2BF16Z256rr VR256X:$src)>;
def : Pat<(v8bf16 (int_x86_vcvtneps2bf16256 (loadv8f32 addr:$src))),
(VCVTNEPS2BF16Z256rm addr:$src)>;
def : Pat<(v8bf16 (X86VBroadcastld16 addr:$src)),
(VPBROADCASTWZ128rm addr:$src)>;
def : Pat<(v16bf16 (X86VBroadcastld16 addr:$src)),
(VPBROADCASTWZ256rm addr:$src)>;
def : Pat<(v8bf16 (X86VBroadcast (v8bf16 VR128X:$src))),
(VPBROADCASTWZ128rr VR128X:$src)>;
def : Pat<(v16bf16 (X86VBroadcast (v8bf16 VR128X:$src))),
(VPBROADCASTWZ256rr VR128X:$src)>;
// TODO: No scalar broadcast due to we don't support legal scalar bf16 so far.
}
let Predicates = [HasBF16] in {
def : Pat<(v32bf16 (X86VBroadcastld16 addr:$src)),
(VPBROADCASTWZrm addr:$src)>;
def : Pat<(v32bf16 (X86VBroadcast (v8bf16 VR128X:$src))),
(VPBROADCASTWZrr VR128X:$src)>;
// TODO: No scalar broadcast due to we don't support legal scalar bf16 so far.
}
let Constraints = "$src1 = $dst" in {

19
contrib/llvm-project/llvm/tools/llvm-mca/llvm-mca.cpp
View file

@ -401,11 +401,6 @@ int main(int argc, char **argv) {
// Tell SrcMgr about this buffer, which is what the parser will pick up.
SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc());
MCContext Ctx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr);
std::unique_ptr<MCObjectFileInfo> MOFI(
TheTarget->createMCObjectFileInfo(Ctx, /*PIC=*/false));
Ctx.setObjectFileInfo(MOFI.get());
std::unique_ptr<buffer_ostream> BOS;
std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
@ -433,7 +428,11 @@ int main(int argc, char **argv) {
}
// Parse the input and create CodeRegions that llvm-mca can analyze.
mca::AsmAnalysisRegionGenerator CRG(*TheTarget, SrcMgr, Ctx, *MAI, *STI,
MCContext ACtx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr);
std::unique_ptr<MCObjectFileInfo> AMOFI(
TheTarget->createMCObjectFileInfo(ACtx, /*PIC=*/false));
ACtx.setObjectFileInfo(AMOFI.get());
mca::AsmAnalysisRegionGenerator CRG(*TheTarget, SrcMgr, ACtx, *MAI, *STI,
*MCII);
Expected<const mca::AnalysisRegions &> RegionsOrErr =
CRG.parseAnalysisRegions(std::move(IPtemp));
@ -471,7 +470,11 @@ int main(int argc, char **argv) {
// Parse the input and create InstrumentRegion that llvm-mca
// can use to improve analysis.
mca::AsmInstrumentRegionGenerator IRG(*TheTarget, SrcMgr, Ctx, *MAI, *STI,
MCContext ICtx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr);
std::unique_ptr<MCObjectFileInfo> IMOFI(
TheTarget->createMCObjectFileInfo(ICtx, /*PIC=*/false));
ICtx.setObjectFileInfo(IMOFI.get());
mca::AsmInstrumentRegionGenerator IRG(*TheTarget, SrcMgr, ICtx, *MAI, *STI,
*MCII, *IM);
Expected<const mca::InstrumentRegions &> InstrumentRegionsOrErr =
IRG.parseInstrumentRegions(std::move(IPtemp));
@ -547,7 +550,7 @@ int main(int argc, char **argv) {
unsigned RegionIdx = 0;
std::unique_ptr<MCCodeEmitter> MCE(
TheTarget->createMCCodeEmitter(*MCII, Ctx));
TheTarget->createMCCodeEmitter(*MCII, ACtx));
assert(MCE && "Unable to create code emitter!");
std::unique_ptr<MCAsmBackend> MAB(TheTarget->createMCAsmBackend(

6
lib/clang/include/VCSVersion.inc
View file

@ -1,10 +1,10 @@
// $FreeBSD$
#define LLVM_REVISION "llvmorg-16.0.4-0-gae42196bc493"
#define LLVM_REVISION "llvmorg-16.0.5-0-g185b81e034ba"
#define LLVM_REPOSITORY "https://github.com/llvm/llvm-project.git"
#define CLANG_REVISION "llvmorg-16.0.4-0-gae42196bc493"
#define CLANG_REVISION "llvmorg-16.0.5-0-g185b81e034ba"
#define CLANG_REPOSITORY "https://github.com/llvm/llvm-project.git"
#define LLDB_REVISION "llvmorg-16.0.4-0-gae42196bc493"
#define LLDB_REVISION "llvmorg-16.0.5-0-g185b81e034ba"
#define LLDB_REPOSITORY "https://github.com/llvm/llvm-project.git"

6
lib/clang/include/clang/Basic/Version.inc
View file

@ -1,10 +1,10 @@
/* $FreeBSD$ */
#define CLANG_VERSION 16.0.4
#define CLANG_VERSION_STRING "16.0.4"
#define CLANG_VERSION 16.0.5
#define CLANG_VERSION_STRING "16.0.5"
#define CLANG_VERSION_MAJOR 16
#define CLANG_VERSION_MAJOR_STRING "16"
#define CLANG_VERSION_MINOR 0
#define CLANG_VERSION_PATCHLEVEL 4
#define CLANG_VERSION_PATCHLEVEL 5
#define CLANG_VENDOR "FreeBSD "

2
lib/clang/include/lld/Common/Version.inc
View file

@ -1,4 +1,4 @@
// Local identifier in __FreeBSD_version style
#define LLD_FREEBSD_VERSION 1400006
#define LLD_VERSION_STRING "16.0.4 (FreeBSD llvmorg-16.0.4-0-gae42196bc493-" __XSTRING(LLD_FREEBSD_VERSION) ")"
#define LLD_VERSION_STRING "16.0.5 (FreeBSD llvmorg-16.0.5-0-g185b81e034ba-" __XSTRING(LLD_FREEBSD_VERSION) ")"

6
lib/clang/include/lldb/Version/Version.inc
View file

@ -1,6 +1,6 @@
#define LLDB_VERSION 16.0.4
#define LLDB_VERSION_STRING "16.0.4"
#define LLDB_VERSION 16.0.5
#define LLDB_VERSION_STRING "16.0.5"
#define LLDB_VERSION_MAJOR 16
#define LLDB_VERSION_MINOR 0
#define LLDB_VERSION_PATCH 4
#define LLDB_VERSION_PATCH 5
/* #undef LLDB_FULL_VERSION_STRING */

4
lib/clang/include/llvm/Config/config.h
View file

@ -348,10 +348,10 @@
#define PACKAGE_NAME "LLVM"
/* Define to the full name and version of this package. */
#define PACKAGE_STRING "LLVM 16.0.4"
#define PACKAGE_STRING "LLVM 16.0.5"
/* Define to the version of this package. */
#define PACKAGE_VERSION "16.0.4"
#define PACKAGE_VERSION "16.0.5"
/* Define to the vendor of this package. */
/* #undef PACKAGE_VENDOR */

4
lib/clang/include/llvm/Config/llvm-config.h
View file

@ -74,10 +74,10 @@
#define LLVM_VERSION_MINOR 0
/* Patch version of the LLVM API */
#define LLVM_VERSION_PATCH 4
#define LLVM_VERSION_PATCH 5
/* LLVM version string */
#define LLVM_VERSION_STRING "16.0.4"
#define LLVM_VERSION_STRING "16.0.5"
/* Whether LLVM records statistics for use with GetStatistics(),
* PrintStatistics() or PrintStatisticsJSON()

2
lib/clang/include/llvm/Support/VCSRevision.h
View file

@ -1,3 +1,3 @@
/* $FreeBSD$ */
#define LLVM_REVISION "llvmorg-16.0.4-0-gae42196bc493"
#define LLVM_REVISION "llvmorg-16.0.5-0-g185b81e034ba"
#define LLVM_REPOSITORY "https://github.com/llvm/llvm-project.git"