shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[NFC][Clang][AST] Adopt llvm::copy in Clang AST (#145192)

Browse Source
This commit is contained in:
Rahul Joshi 2025-06-23 10:10:53 -07:00 committed by GitHub
parent f40909f605
commit ed75e55a70
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 73 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
clang/include/clang/AST/ASTContext.h
View File

@ -814,7 +814,7 @@ public:
llvm::StringRef backupStr(llvm::StringRef S) const {
char *Buf = new (*this) char[S.size()];
std::copy(S.begin(), S.end(), Buf);
llvm::copy(S, Buf);
return llvm::StringRef(Buf, S.size());
}

14
clang/include/clang/AST/OpenMPClause.h
View File

@ -387,7 +387,7 @@ public:
assert(
DK.size() == NumKinds &&
"Number of directive kinds is not the same as the preallocated buffer");
std::copy(DK.begin(), DK.end(), getDirectiveKinds().begin());
llvm::copy(DK, getDirectiveKinds().begin());
}
SourceLocation getLParenLoc() { return LParenLoc; }
@ -5917,7 +5917,7 @@ protected:
void setUniqueDecls(ArrayRef<ValueDecl *> UDs) {
assert(UDs.size() == NumUniqueDeclarations &&
"Unexpected amount of unique declarations.");
std::copy(UDs.begin(), UDs.end(), getUniqueDeclsRef().begin());
llvm::copy(UDs, getUniqueDeclsRef().begin());
}
/// Get the number of lists per declaration that are in the trailing
@ -5939,7 +5939,7 @@ protected:
void setDeclNumLists(ArrayRef<unsigned> DNLs) {
assert(DNLs.size() == NumUniqueDeclarations &&
"Unexpected amount of list numbers.");
std::copy(DNLs.begin(), DNLs.end(), getDeclNumListsRef().begin());
llvm::copy(DNLs, getDeclNumListsRef().begin());
}
/// Get the cumulative component lists sizes that are in the trailing
@ -5965,7 +5965,7 @@ protected:
void setComponentListSizes(ArrayRef<unsigned> CLSs) {
assert(CLSs.size() == NumComponentLists &&
"Unexpected amount of component lists.");
std::copy(CLSs.begin(), CLSs.end(), getComponentListSizesRef().begin());
llvm::copy(CLSs, getComponentListSizesRef().begin());
}
/// Get the components that are in the trailing objects of the class.
@ -5989,7 +5989,7 @@ protected:
"Unexpected amount of component lists.");
assert(CLSs.size() == NumComponentLists &&
"Unexpected amount of list sizes.");
std::copy(Components.begin(), Components.end(), getComponentsRef().begin());
llvm::copy(Components, getComponentsRef().begin());
}
/// Fill the clause information from the list of declarations and
@ -6063,7 +6063,7 @@ protected:
++CLSI;
// Append components after the current components iterator.
CI = std::copy(C.begin(), C.end(), CI);
CI = llvm::copy(C, CI);
}
}
}
@ -6107,7 +6107,7 @@ protected:
"Unexpected number of user-defined mappers.");
assert(SupportsMapper &&
"Must be a clause that is possible to have user-defined mappers");
std::copy(DMDs.begin(), DMDs.end(), getUDMapperRefs().begin());
llvm::copy(DMDs, getUDMapperRefs().begin());
}
public:

2
clang/include/clang/AST/Stmt.h
View File

@ -2214,7 +2214,7 @@ class AttributedStmt final
: ValueStmt(AttributedStmtClass), SubStmt(SubStmt) {
AttributedStmtBits.NumAttrs = Attrs.size();
AttributedStmtBits.AttrLoc = Loc;
std::copy(Attrs.begin(), Attrs.end(), getAttrArrayPtr());
llvm::copy(Attrs, getAttrArrayPtr());
}
explicit AttributedStmt(EmptyShell Empty, unsigned NumAttrs)

2
clang/lib/AST/ASTImporter.cpp
View File

@ -4123,7 +4123,7 @@ ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
return std::move(Err);
auto **Memory =
new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
llvm::copy(CtorInitializers, Memory);
auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
ToCtor->setCtorInitializers(Memory);
ToCtor->setNumCtorInitializers(NumInitializers);

19
clang/lib/AST/Decl.cpp
View File

@ -2110,7 +2110,7 @@ void QualifierInfo::setTemplateParameterListsInfo(
if (!TPLists.empty()) {
TemplParamLists = new (Context) TemplateParameterList *[TPLists.size()];
NumTemplParamLists = TPLists.size();
std::copy(TPLists.begin(), TPLists.end(), TemplParamLists);
llvm::copy(TPLists, TemplParamLists);
}
}
@ -3753,7 +3753,7 @@ void FunctionDecl::setParams(ASTContext &C,
// Zero params -> null pointer.
if (!NewParamInfo.empty()) {
ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()];
std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
llvm::copy(NewParamInfo, ParamInfo);
}
}
@ -5322,7 +5322,7 @@ void BlockDecl::setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
if (!NewParamInfo.empty()) {
NumParams = NewParamInfo.size();
ParamInfo = new (getASTContext()) ParmVarDecl*[NewParamInfo.size()];
std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
llvm::copy(NewParamInfo, ParamInfo);
}
}
@ -5379,7 +5379,7 @@ PragmaCommentDecl *PragmaCommentDecl::Create(const ASTContext &C,
PragmaCommentDecl *PCD =
new (C, DC, additionalSizeToAlloc<char>(Arg.size() + 1))
PragmaCommentDecl(DC, CommentLoc, CommentKind);
memcpy(PCD->getTrailingObjects(), Arg.data(), Arg.size());
llvm::copy(Arg, PCD->getTrailingObjects());
PCD->getTrailingObjects()[Arg.size()] = '\0';
return PCD;
}
@ -5401,9 +5401,9 @@ PragmaDetectMismatchDecl::Create(const ASTContext &C, TranslationUnitDecl *DC,
PragmaDetectMismatchDecl *PDMD =
new (C, DC, additionalSizeToAlloc<char>(ValueStart + Value.size() + 1))
PragmaDetectMismatchDecl(DC, Loc, ValueStart);
memcpy(PDMD->getTrailingObjects(), Name.data(), Name.size());
llvm::copy(Name, PDMD->getTrailingObjects());
PDMD->getTrailingObjects()[Name.size()] = '\0';
memcpy(PDMD->getTrailingObjects() + ValueStart, Value.data(), Value.size());
llvm::copy(Value, PDMD->getTrailingObjects() + ValueStart);
PDMD->getTrailingObjects()[ValueStart + Value.size()] = '\0';
return PDMD;
}
@ -5443,7 +5443,7 @@ LabelDecl *LabelDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) {
void LabelDecl::setMSAsmLabel(StringRef Name) {
char *Buffer = new (getASTContext(), 1) char[Name.size() + 1];
memcpy(Buffer, Name.data(), Name.size());
llvm::copy(Name, Buffer);
Buffer[Name.size()] = '\0';
MSAsmName = Buffer;
}
@ -5828,7 +5828,7 @@ void HLSLBufferDecl::setDefaultBufferDecls(ArrayRef<Decl *> Decls) {
// allocate array for default decls with ASTContext allocator
Decl **DeclsArray = new (getASTContext()) Decl *[Decls.size()];
std::copy(Decls.begin(), Decls.end(), DeclsArray);
llvm::copy(Decls, DeclsArray);
DefaultBufferDecls = ArrayRef<Decl *>(DeclsArray, Decls.size());
}
@ -5869,8 +5869,7 @@ HLSLRootSignatureDecl *HLSLRootSignatureDecl::Create(
RootElements.size()))
HLSLRootSignatureDecl(DC, Loc, ID, RootElements.size());
auto *StoredElems = RSDecl->getElems();
std::uninitialized_copy(RootElements.begin(), RootElements.end(),
StoredElems);
llvm::uninitialized_copy(RootElements, StoredElems);
return RSDecl;
}

2
clang/lib/AST/DeclObjC.cpp
View File

@ -1512,7 +1512,7 @@ ObjCTypeParamList::ObjCTypeParamList(SourceLocation lAngleLoc,
ArrayRef<ObjCTypeParamDecl *> typeParams,
SourceLocation rAngleLoc)
: Brackets(lAngleLoc, rAngleLoc), NumParams(typeParams.size()) {
std::copy(typeParams.begin(), typeParams.end(), begin());
llvm::copy(typeParams, begin());
}
ObjCTypeParamList *ObjCTypeParamList::create(

17
clang/lib/AST/ExprCXX.cpp
View File

@ -261,9 +261,8 @@ CXXNewExpr::CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew,
getTrailingObjects<Stmt *>()[arraySizeOffset()] = *ArraySize;
if (Initializer)
getTrailingObjects<Stmt *>()[initExprOffset()] = Initializer;
for (unsigned I = 0; I != PlacementArgs.size(); ++I)
getTrailingObjects<Stmt *>()[placementNewArgsOffset() + I] =
PlacementArgs[I];
llvm::copy(PlacementArgs,
getTrailingObjects<Stmt *>() + placementNewArgsOffset());
if (IsParenTypeId)
getTrailingObjects<SourceRange>()[0] = TypeIdParens;
@ -1208,10 +1207,8 @@ CXXConstructExpr::CXXConstructExpr(
CXXConstructExprBits.Loc = Loc;
Stmt **TrailingArgs = getTrailingArgs();
for (unsigned I = 0, N = Args.size(); I != N; ++I) {
assert(Args[I] && "NULL argument in CXXConstructExpr!");
TrailingArgs[I] = Args[I];
}
llvm::copy(Args, TrailingArgs);
assert(llvm::all_of(Args, [](const Stmt *Arg) { return Arg != nullptr; }));
// CXXTemporaryObjectExpr does this itself after setting its TypeSourceInfo.
if (SC == CXXConstructExprClass)
@ -1472,8 +1469,7 @@ CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(
RParenLoc(RParenLoc) {
CXXUnresolvedConstructExprBits.NumArgs = Args.size();
auto **StoredArgs = getTrailingObjects();
for (unsigned I = 0; I != Args.size(); ++I)
StoredArgs[I] = Args[I];
llvm::copy(Args, StoredArgs);
setDependence(computeDependence(this));
}
@ -1885,8 +1881,7 @@ TypeTraitExpr::TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind,
assert(Args.size() == TypeTraitExprBits.NumArgs &&
"TypeTraitExprBits.NumArgs overflow!");
auto **ToArgs = getTrailingObjects<TypeSourceInfo *>();
for (unsigned I = 0, N = Args.size(); I != N; ++I)
ToArgs[I] = Args[I];
llvm::copy(Args, ToArgs);
setDependence(computeDependence(this));

6
clang/lib/AST/ExprConcepts.cpp
View File

@ -144,10 +144,8 @@ RequiresExpr::RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc,
if (RequirementContainsError(R))
setDependence(getDependence() | ExprDependence::Error);
}
std::copy(LocalParameters.begin(), LocalParameters.end(),
getTrailingObjects<ParmVarDecl *>());
std::copy(Requirements.begin(), Requirements.end(),
getTrailingObjects<concepts::Requirement *>());
llvm::copy(LocalParameters, getTrailingObjects<ParmVarDecl *>());
llvm::copy(Requirements, getTrailingObjects<concepts::Requirement *>());
RequiresExprBits.IsSatisfied |= Dependent;
// FIXME: move the computing dependency logic to ComputeDependence.h
if (ContainsUnexpandedParameterPack)

6
clang/lib/AST/ExprObjC.cpp
View File

@ -163,10 +163,8 @@ void ObjCMessageExpr::initArgsAndSelLocs(ArrayRef<Expr *> Args,
MyArgs[I] = Args[I];
SelLocsKind = SelLocsK;
if (!isImplicit()) {
if (SelLocsK == SelLoc_NonStandard)
std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs());
}
if (!isImplicit() && SelLocsK == SelLoc_NonStandard)
llvm::copy(SelLocs, getStoredSelLocs());
}
ObjCMessageExpr *

72
clang/lib/AST/OpenMPClause.cpp
View File

@ -428,7 +428,7 @@ OMPUpdateClause *OMPUpdateClause::CreateEmpty(const ASTContext &C,
void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
assert(VL.size() == varlist_size() &&
"Number of private copies is not the same as the preallocated buffer");
std::copy(VL.begin(), VL.end(), varlist_end());
llvm::copy(VL, varlist_end());
}
OMPPrivateClause *
@ -453,13 +453,13 @@ OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
assert(VL.size() == varlist_size() &&
"Number of private copies is not the same as the preallocated buffer");
std::copy(VL.begin(), VL.end(), varlist_end());
llvm::copy(VL, varlist_end());
}
void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
assert(VL.size() == varlist_size() &&
"Number of inits is not the same as the preallocated buffer");
std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
llvm::copy(VL, getPrivateCopies().end());
}
OMPFirstprivateClause *
@ -486,29 +486,28 @@ OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
assert(PrivateCopies.size() == varlist_size() &&
"Number of private copies is not the same as the preallocated buffer");
std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
llvm::copy(PrivateCopies, varlist_end());
}
void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
"not the same as the "
"preallocated buffer");
std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
llvm::copy(SrcExprs, getPrivateCopies().end());
}
void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
assert(DstExprs.size() == varlist_size() && "Number of destination "
"expressions is not the same as "
"the preallocated buffer");
std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
llvm::copy(DstExprs, getSourceExprs().end());
}
void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
assert(AssignmentOps.size() == varlist_size() &&
"Number of assignment expressions is not the same as the preallocated "
"buffer");
std::copy(AssignmentOps.begin(), AssignmentOps.end(),
getDestinationExprs().end());
llvm::copy(AssignmentOps, getDestinationExprs().end());
}
OMPLastprivateClause *OMPLastprivateClause::Create(
@ -555,32 +554,32 @@ OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) {
void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) {
assert(PL.size() == varlist_size() &&
"Number of privates is not the same as the preallocated buffer");
std::copy(PL.begin(), PL.end(), varlist_end());
llvm::copy(PL, varlist_end());
}
void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
assert(IL.size() == varlist_size() &&
"Number of inits is not the same as the preallocated buffer");
std::copy(IL.begin(), IL.end(), getPrivates().end());
llvm::copy(IL, getPrivates().end());
}
void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
assert(UL.size() == varlist_size() &&
"Number of updates is not the same as the preallocated buffer");
std::copy(UL.begin(), UL.end(), getInits().end());
llvm::copy(UL, getInits().end());
}
void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
assert(FL.size() == varlist_size() &&
"Number of final updates is not the same as the preallocated buffer");
std::copy(FL.begin(), FL.end(), getUpdates().end());
llvm::copy(FL, getUpdates().end());
}
void OMPLinearClause::setUsedExprs(ArrayRef<Expr *> UE) {
assert(
UE.size() == varlist_size() + 1 &&
"Number of used expressions is not the same as the preallocated buffer");
std::copy(UE.begin(), UE.end(), getFinals().end() + 2);
llvm::copy(UE, getFinals().end() + 2);
}
OMPLinearClause *OMPLinearClause::Create(
@ -659,22 +658,21 @@ void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
"not the same as the "
"preallocated buffer");
std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
llvm::copy(SrcExprs, varlist_end());
}
void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
assert(DstExprs.size() == varlist_size() && "Number of destination "
"expressions is not the same as "
"the preallocated buffer");
std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
llvm::copy(DstExprs, getSourceExprs().end());
}
void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
assert(AssignmentOps.size() == varlist_size() &&
"Number of assignment expressions is not the same as the preallocated "
"buffer");
std::copy(AssignmentOps.begin(), AssignmentOps.end(),
getDestinationExprs().end());
llvm::copy(AssignmentOps, getDestinationExprs().end());
}
OMPCopyinClause *OMPCopyinClause::Create(
@ -700,22 +698,21 @@ void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
"not the same as the "
"preallocated buffer");
std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
llvm::copy(SrcExprs, varlist_end());
}
void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
assert(DstExprs.size() == varlist_size() && "Number of destination "
"expressions is not the same as "
"the preallocated buffer");
std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
llvm::copy(DstExprs, getSourceExprs().end());
}
void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
assert(AssignmentOps.size() == varlist_size() &&
"Number of assignment expressions is not the same as the preallocated "
"buffer");
std::copy(AssignmentOps.begin(), AssignmentOps.end(),
getDestinationExprs().end());
llvm::copy(AssignmentOps, getDestinationExprs().end());
}
OMPCopyprivateClause *OMPCopyprivateClause::Create(
@ -741,28 +738,28 @@ OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
assert(Privates.size() == varlist_size() &&
"Number of private copies is not the same as the preallocated buffer");
std::copy(Privates.begin(), Privates.end(), varlist_end());
llvm::copy(Privates, varlist_end());
}
void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
assert(
LHSExprs.size() == varlist_size() &&
"Number of LHS expressions is not the same as the preallocated buffer");
std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
llvm::copy(LHSExprs, getPrivates().end());
}
void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
assert(
RHSExprs.size() == varlist_size() &&
"Number of RHS expressions is not the same as the preallocated buffer");
std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
llvm::copy(RHSExprs, getLHSExprs().end());
}
void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
assert(ReductionOps.size() == varlist_size() && "Number of reduction "
"expressions is not the same "
"as the preallocated buffer");
std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
llvm::copy(ReductionOps, getRHSExprs().end());
}
void OMPReductionClause::setInscanCopyOps(ArrayRef<Expr *> Ops) {
@ -843,28 +840,28 @@ OMPReductionClause::CreateEmpty(const ASTContext &C, unsigned N,
void OMPTaskReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
assert(Privates.size() == varlist_size() &&
"Number of private copies is not the same as the preallocated buffer");
std::copy(Privates.begin(), Privates.end(), varlist_end());
llvm::copy(Privates, varlist_end());
}
void OMPTaskReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
assert(
LHSExprs.size() == varlist_size() &&
"Number of LHS expressions is not the same as the preallocated buffer");
std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
llvm::copy(LHSExprs, getPrivates().end());
}
void OMPTaskReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
assert(
RHSExprs.size() == varlist_size() &&
"Number of RHS expressions is not the same as the preallocated buffer");
std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
llvm::copy(RHSExprs, getLHSExprs().end());
}
void OMPTaskReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
assert(ReductionOps.size() == varlist_size() && "Number of task reduction "
"expressions is not the same "
"as the preallocated buffer");
std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
llvm::copy(ReductionOps, getRHSExprs().end());
}
OMPTaskReductionClause *OMPTaskReductionClause::Create(
@ -896,28 +893,28 @@ OMPTaskReductionClause *OMPTaskReductionClause::CreateEmpty(const ASTContext &C,
void OMPInReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
assert(Privates.size() == varlist_size() &&
"Number of private copies is not the same as the preallocated buffer");
std::copy(Privates.begin(), Privates.end(), varlist_end());
llvm::copy(Privates, varlist_end());
}
void OMPInReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
assert(
LHSExprs.size() == varlist_size() &&
"Number of LHS expressions is not the same as the preallocated buffer");
std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
llvm::copy(LHSExprs, getPrivates().end());
}
void OMPInReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
assert(
RHSExprs.size() == varlist_size() &&
"Number of RHS expressions is not the same as the preallocated buffer");
std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
llvm::copy(RHSExprs, getLHSExprs().end());
}
void OMPInReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
assert(ReductionOps.size() == varlist_size() && "Number of in reduction "
"expressions is not the same "
"as the preallocated buffer");
std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
llvm::copy(ReductionOps, getRHSExprs().end());
}
void OMPInReductionClause::setTaskgroupDescriptors(
@ -925,8 +922,7 @@ void OMPInReductionClause::setTaskgroupDescriptors(
assert(TaskgroupDescriptors.size() == varlist_size() &&
"Number of in reduction descriptors is not the same as the "
"preallocated buffer");
std::copy(TaskgroupDescriptors.begin(), TaskgroupDescriptors.end(),
getReductionOps().end());
llvm::copy(TaskgroupDescriptors, getReductionOps().end());
}
OMPInReductionClause *OMPInReductionClause::Create(
@ -1322,13 +1318,13 @@ OMPFromClause::CreateEmpty(const ASTContext &C,
void OMPUseDevicePtrClause::setPrivateCopies(ArrayRef<Expr *> VL) {
assert(VL.size() == varlist_size() &&
"Number of private copies is not the same as the preallocated buffer");
std::copy(VL.begin(), VL.end(), varlist_end());
llvm::copy(VL, varlist_end());
}
void OMPUseDevicePtrClause::setInits(ArrayRef<Expr *> VL) {
assert(VL.size() == varlist_size() &&
"Number of inits is not the same as the preallocated buffer");
std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
llvm::copy(VL, getPrivateCopies().end());
}
OMPUseDevicePtrClause *OMPUseDevicePtrClause::Create(
@ -1543,7 +1539,7 @@ OMPNontemporalClause *OMPNontemporalClause::CreateEmpty(const ASTContext &C,
void OMPNontemporalClause::setPrivateRefs(ArrayRef<Expr *> VL) {
assert(VL.size() == varlist_size() && "Number of private references is not "
"the same as the preallocated buffer");
std::copy(VL.begin(), VL.end(), varlist_end());
llvm::copy(VL, varlist_end());
}
OMPInclusiveClause *OMPInclusiveClause::Create(const ASTContext &C,

9
clang/lib/AST/Stmt.cpp
View File

@ -384,8 +384,7 @@ CompoundStmt::CompoundStmt(ArrayRef<Stmt *> Stmts, FPOptionsOverride FPFeatures,
void CompoundStmt::setStmts(ArrayRef<Stmt *> Stmts) {
assert(CompoundStmtBits.NumStmts == Stmts.size() &&
"NumStmts doesn't fit in bits of CompoundStmtBits.NumStmts!");
std::copy(Stmts.begin(), Stmts.end(), body_begin());
llvm::copy(Stmts, body_begin());
}
CompoundStmt *CompoundStmt::Create(const ASTContext &C, ArrayRef<Stmt *> Stmts,
@ -947,10 +946,10 @@ void MSAsmStmt::initialize(const ASTContext &C, StringRef asmstr,
AsmStr = copyIntoContext(C, asmstr);
Exprs = new (C) Stmt*[exprs.size()];
std::copy(exprs.begin(), exprs.end(), Exprs);
llvm::copy(exprs, Exprs);
AsmToks = new (C) Token[asmtoks.size()];
std::copy(asmtoks.begin(), asmtoks.end(), AsmToks);
llvm::copy(asmtoks, AsmToks);
Constraints = new (C) StringRef[exprs.size()];
std::transform(constraints.begin(), constraints.end(), Constraints,
@ -1385,7 +1384,7 @@ CapturedStmt::CapturedStmt(Stmt *S, CapturedRegionKind Kind,
// Copy all Capture objects.
Capture *Buffer = getStoredCaptures();
std::copy(Captures.begin(), Captures.end(), Buffer);
llvm::copy(Captures, Buffer);
}
CapturedStmt::CapturedStmt(EmptyShell Empty, unsigned NumCaptures)

5
clang/lib/AST/StmtCXX.cpp
View File

@ -42,7 +42,7 @@ CXXTryStmt::CXXTryStmt(SourceLocation tryLoc, CompoundStmt *tryBlock,
: Stmt(CXXTryStmtClass), TryLoc(tryLoc), NumHandlers(handlers.size()) {
Stmt **Stmts = getStmts();
Stmts[0] = tryBlock;
std::copy(handlers.begin(), handlers.end(), Stmts + 1);
llvm::copy(handlers, Stmts + 1);
}
CXXForRangeStmt::CXXForRangeStmt(Stmt *Init, DeclStmt *Range,
@ -123,6 +123,5 @@ CoroutineBodyStmt::CoroutineBodyStmt(CoroutineBodyStmt::CtorArgs const &Args)
SubStmts[CoroutineBodyStmt::ReturnStmt] = Args.ReturnStmt;
SubStmts[CoroutineBodyStmt::ReturnStmtOnAllocFailure] =
Args.ReturnStmtOnAllocFailure;
std::copy(Args.ParamMoves.begin(), Args.ParamMoves.end(),
const_cast<Stmt **>(getParamMoves().data()));
llvm::copy(Args.ParamMoves, const_cast<Stmt **>(getParamMoves().data()));
}

3
clang/lib/AST/Type.cpp
View File

@ -3982,9 +3982,8 @@ CountAttributedType::CountAttributedType(
CountAttributedTypeBits.CountInBytes = CountInBytes;
CountAttributedTypeBits.OrNull = OrNull;
auto *DeclSlot = getTrailingObjects();
llvm::copy(CoupledDecls, DeclSlot);
Decls = llvm::ArrayRef(DeclSlot, CoupledDecls.size());
for (unsigned i = 0; i != CoupledDecls.size(); ++i)
DeclSlot[i] = CoupledDecls[i];
}
StringRef CountAttributedType::getAttributeName(bool WithMacroPrefix) const {