diff --git a/clang/lib/CodeGen/CGAtomic.cpp b/clang/lib/CodeGen/CGAtomic.cpp --- a/clang/lib/CodeGen/CGAtomic.cpp +++ b/clang/lib/CodeGen/CGAtomic.cpp @@ -307,7 +307,7 @@ const CGFunctionInfo &fnInfo = CGF.CGM.getTypes().arrangeBuiltinFunctionCall(resultType, args); llvm::FunctionType *fnTy = CGF.CGM.getTypes().GetFunctionType(fnInfo); - llvm::AttrBuilder fnAttrB; + llvm::AttrBuilder fnAttrB(CGF.getLLVMContext()); fnAttrB.addAttribute(llvm::Attribute::NoUnwind); fnAttrB.addAttribute(llvm::Attribute::WillReturn); llvm::AttributeList fnAttrs = llvm::AttributeList::get( diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -4925,7 +4925,7 @@ llvm::Value *Block = Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy); - AttrBuilder B; + AttrBuilder B(Builder.getContext()); B.addByValAttr(NDRangeL.getAddress(*this).getElementType()); llvm::AttributeList ByValAttrSet = llvm::AttributeList::get(CGM.getModule().getContext(), 3U, B); diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp --- a/clang/lib/CodeGen/CGCall.cpp +++ b/clang/lib/CodeGen/CGCall.cpp @@ -1892,7 +1892,7 @@ } void CodeGenModule::addDefaultFunctionDefinitionAttributes(llvm::Function &F) { - llvm::AttrBuilder FuncAttrs; + llvm::AttrBuilder FuncAttrs(F.getContext()); getDefaultFunctionAttributes(F.getName(), F.hasOptNone(), /* AttrOnCallSite = */ false, FuncAttrs); // TODO: call GetCPUAndFeaturesAttributes? @@ -2014,8 +2014,8 @@ llvm::AttributeList &AttrList, unsigned &CallingConv, bool AttrOnCallSite, bool IsThunk) { - llvm::AttrBuilder FuncAttrs; - llvm::AttrBuilder RetAttrs; + llvm::AttrBuilder FuncAttrs(getLLVMContext()); + llvm::AttrBuilder RetAttrs(getLLVMContext()); // Collect function IR attributes from the CC lowering. // We'll collect the paramete and result attributes later. @@ -2302,7 +2302,7 @@ // Attach attributes to sret. if (IRFunctionArgs.hasSRetArg()) { - llvm::AttrBuilder SRETAttrs; + llvm::AttrBuilder SRETAttrs(getLLVMContext()); SRETAttrs.addStructRetAttr(getTypes().ConvertTypeForMem(RetTy)); hasUsedSRet = true; if (RetAI.getInReg()) @@ -2314,7 +2314,7 @@ // Attach attributes to inalloca argument. if (IRFunctionArgs.hasInallocaArg()) { - llvm::AttrBuilder Attrs; + llvm::AttrBuilder Attrs(getLLVMContext()); Attrs.addInAllocaAttr(FI.getArgStruct()); ArgAttrs[IRFunctionArgs.getInallocaArgNo()] = llvm::AttributeSet::get(getLLVMContext(), Attrs); @@ -2329,7 +2329,7 @@ assert(IRArgs.second == 1 && "Expected only a single `this` pointer."); - llvm::AttrBuilder Attrs; + llvm::AttrBuilder Attrs(getLLVMContext()); QualType ThisTy = FI.arg_begin()->type.castAs()->getPointeeType(); @@ -2364,7 +2364,7 @@ I != E; ++I, ++ArgNo) { QualType ParamType = I->type; const ABIArgInfo &AI = I->info; - llvm::AttrBuilder Attrs; + llvm::AttrBuilder Attrs(getLLVMContext()); // Add attribute for padding argument, if necessary. if (IRFunctionArgs.hasPaddingArg(ArgNo)) { @@ -2372,7 +2372,7 @@ ArgAttrs[IRFunctionArgs.getPaddingArgNo(ArgNo)] = llvm::AttributeSet::get( getLLVMContext(), - llvm::AttrBuilder().addAttribute(llvm::Attribute::InReg)); + llvm::AttrBuilder(getLLVMContext()).addAttribute(llvm::Attribute::InReg)); } } @@ -2747,11 +2747,11 @@ QualType ETy = ArrTy->getElementType(); llvm::Align Alignment = CGM.getNaturalTypeAlignment(ETy).getAsAlign(); - AI->addAttrs(llvm::AttrBuilder().addAlignmentAttr(Alignment)); + AI->addAttrs(llvm::AttrBuilder(getLLVMContext()).addAlignmentAttr(Alignment)); uint64_t ArrSize = ArrTy->getSize().getZExtValue(); if (!ETy->isIncompleteType() && ETy->isConstantSizeType() && ArrSize) { - llvm::AttrBuilder Attrs; + llvm::AttrBuilder Attrs(getLLVMContext()); Attrs.addDereferenceableAttr( getContext().getTypeSizeInChars(ETy).getQuantity() * ArrSize); @@ -2771,7 +2771,7 @@ QualType ETy = ArrTy->getElementType(); llvm::Align Alignment = CGM.getNaturalTypeAlignment(ETy).getAsAlign(); - AI->addAttrs(llvm::AttrBuilder().addAlignmentAttr(Alignment)); + AI->addAttrs(llvm::AttrBuilder(getLLVMContext()).addAlignmentAttr(Alignment)); if (!getContext().getTargetAddressSpace(ETy) && !CGM.getCodeGenOpts().NullPointerIsValid) AI->addAttr(llvm::Attribute::NonNull); @@ -2793,7 +2793,7 @@ AlignmentCI->getLimitedValue(llvm::Value::MaximumAlignment); if (AI->getParamAlign().valueOrOne() < AlignmentInt) { AI->removeAttr(llvm::Attribute::AttrKind::Alignment); - AI->addAttrs(llvm::AttrBuilder().addAlignmentAttr( + AI->addAttrs(llvm::AttrBuilder(getLLVMContext()).addAlignmentAttr( llvm::Align(AlignmentInt))); } } diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp --- a/clang/lib/CodeGen/CGExpr.cpp +++ b/clang/lib/CodeGen/CGExpr.cpp @@ -3178,7 +3178,7 @@ bool MayReturn = !IsFatal || RecoverKind == CheckRecoverableKind::AlwaysRecoverable; - llvm::AttrBuilder B; + llvm::AttrBuilder B(CGF.getLLVMContext()); if (!MayReturn) { B.addAttribute(llvm::Attribute::NoReturn) .addAttribute(llvm::Attribute::NoUnwind); diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/clang/lib/CodeGen/CodeGenModule.cpp @@ -1819,7 +1819,7 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F) { - llvm::AttrBuilder B; + llvm::AttrBuilder B(F->getContext()); if (CodeGenOpts.UnwindTables) B.addAttribute(llvm::Attribute::UWTable); @@ -1982,7 +1982,7 @@ void CodeGenModule::setLLVMFunctionFEnvAttributes(const FunctionDecl *D, llvm::Function *F) { if (D->hasAttr()) { - llvm::AttrBuilder FuncAttrs; + llvm::AttrBuilder FuncAttrs(F->getContext()); FuncAttrs.addAttribute("strictfp"); F->addFnAttrs(FuncAttrs); } @@ -2092,7 +2092,7 @@ if (!D->getAttr()) F->addFnAttr("implicit-section-name", SA->getName()); - llvm::AttrBuilder Attrs; + llvm::AttrBuilder Attrs(F->getContext()); if (GetCPUAndFeaturesAttributes(GD, Attrs)) { // We know that GetCPUAndFeaturesAttributes will always have the // newest set, since it has the newest possible FunctionDecl, so the @@ -3785,7 +3785,7 @@ if (D) SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk); if (ExtraAttrs.hasFnAttrs()) { - llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeList::FunctionIndex); + llvm::AttrBuilder B(F->getContext(), ExtraAttrs, llvm::AttributeList::FunctionIndex); F->addFnAttrs(B); } diff --git a/clang/lib/CodeGen/TargetInfo.cpp b/clang/lib/CodeGen/TargetInfo.cpp --- a/clang/lib/CodeGen/TargetInfo.cpp +++ b/clang/lib/CodeGen/TargetInfo.cpp @@ -855,19 +855,19 @@ if (const auto *FD = dyn_cast_or_null(D)) { if (const auto *Attr = FD->getAttr()) { llvm::Function *Fn = cast(GV); - llvm::AttrBuilder B; + llvm::AttrBuilder B(GV->getContext()); B.addAttribute("wasm-import-module", Attr->getImportModule()); Fn->addFnAttrs(B); } if (const auto *Attr = FD->getAttr()) { llvm::Function *Fn = cast(GV); - llvm::AttrBuilder B; + llvm::AttrBuilder B(GV->getContext()); B.addAttribute("wasm-import-name", Attr->getImportName()); Fn->addFnAttrs(B); } if (const auto *Attr = FD->getAttr()) { llvm::Function *Fn = cast(GV); - llvm::AttrBuilder B; + llvm::AttrBuilder B(GV->getContext()); B.addAttribute("wasm-export-name", Attr->getExportName()); Fn->addFnAttrs(B); } @@ -6414,7 +6414,7 @@ // AAPCS guarantees that sp will be 8-byte aligned on any public interface, // however this is not necessarily true on taking any interrupt. Instruct // the backend to perform a realignment as part of the function prologue. - llvm::AttrBuilder B; + llvm::AttrBuilder B(Fn->getContext()); B.addStackAlignmentAttr(8); Fn->addFnAttrs(B); } diff --git a/llvm/include/llvm/CodeGen/IndirectThunks.h b/llvm/include/llvm/CodeGen/IndirectThunks.h --- a/llvm/include/llvm/CodeGen/IndirectThunks.h +++ b/llvm/include/llvm/CodeGen/IndirectThunks.h @@ -59,7 +59,7 @@ // Add Attributes so that we don't create a frame, unwind information, or // inline. - AttrBuilder B; + AttrBuilder B(Ctx); B.addAttribute(llvm::Attribute::NoUnwind); B.addAttribute(llvm::Attribute::Naked); F->addFnAttrs(B); diff --git a/llvm/include/llvm/IR/Attributes.h b/llvm/include/llvm/IR/Attributes.h --- a/llvm/include/llvm/IR/Attributes.h +++ b/llvm/include/llvm/IR/Attributes.h @@ -996,8 +996,9 @@ /// value, however, is not. So this can be used as a quick way to test for /// equality, presence of attributes, etc. class AttrBuilder { + LLVMContext &Ctx; std::bitset Attrs; - std::map, SmallString<32>, std::less<>> TargetDepAttrs; + SmallVector TargetDepAttrs; std::array IntAttrs = {}; std::array TypeAttrs = {}; @@ -1005,16 +1006,16 @@ Optional kindToTypeIndex(Attribute::AttrKind Kind) const; public: - AttrBuilder() = default; + AttrBuilder(LLVMContext &Ctx) : Ctx(Ctx) {} AttrBuilder(const AttrBuilder &) = delete; AttrBuilder(AttrBuilder &&) = default; - AttrBuilder(const Attribute &A) { + AttrBuilder(LLVMContext &Ctx, const Attribute &A) : Ctx(Ctx) { addAttribute(A); } - AttrBuilder(AttributeList AS, unsigned Idx); - AttrBuilder(AttributeSet AS); + AttrBuilder(LLVMContext &Ctx, AttributeList AS, unsigned Idx); + AttrBuilder(LLVMContext &Ctx, AttributeSet AS); void clear(); diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp --- a/llvm/lib/AsmParser/LLParser.cpp +++ b/llvm/lib/AsmParser/LLParser.cpp @@ -133,14 +133,17 @@ for (const auto &RAG : ForwardRefAttrGroups) { Value *V = RAG.first; const std::vector &Attrs = RAG.second; - AttrBuilder B; + AttrBuilder B(Context); - for (const auto &Attr : Attrs) - B.merge(NumberedAttrBuilders[Attr]); + for (const auto &Attr : Attrs) { + auto R = NumberedAttrBuilders.find(Attr); + if (R != NumberedAttrBuilders.end()) + B.merge(R->second); + } if (Function *Fn = dyn_cast(V)) { AttributeList AS = Fn->getAttributes(); - AttrBuilder FnAttrs(AS.getFnAttrs()); + AttrBuilder FnAttrs(M->getContext(), AS.getFnAttrs()); AS = AS.removeFnAttributes(Context); FnAttrs.merge(B); @@ -156,27 +159,27 @@ Fn->setAttributes(AS); } else if (CallInst *CI = dyn_cast(V)) { AttributeList AS = CI->getAttributes(); - AttrBuilder FnAttrs(AS.getFnAttrs()); + AttrBuilder FnAttrs(M->getContext(), AS.getFnAttrs()); AS = AS.removeFnAttributes(Context); FnAttrs.merge(B); AS = AS.addFnAttributes(Context, FnAttrs); CI->setAttributes(AS); } else if (InvokeInst *II = dyn_cast(V)) { AttributeList AS = II->getAttributes(); - AttrBuilder FnAttrs(AS.getFnAttrs()); + AttrBuilder FnAttrs(M->getContext(), AS.getFnAttrs()); AS = AS.removeFnAttributes(Context); FnAttrs.merge(B); AS = AS.addFnAttributes(Context, FnAttrs); II->setAttributes(AS); } else if (CallBrInst *CBI = dyn_cast(V)) { AttributeList AS = CBI->getAttributes(); - AttrBuilder FnAttrs(AS.getFnAttrs()); + AttrBuilder FnAttrs(M->getContext(), AS.getFnAttrs()); AS = AS.removeFnAttributes(Context); FnAttrs.merge(B); AS = AS.addFnAttributes(Context, FnAttrs); CBI->setAttributes(AS); } else if (auto *GV = dyn_cast(V)) { - AttrBuilder Attrs(GV->getAttributes()); + AttrBuilder Attrs(M->getContext(), GV->getAttributes()); Attrs.merge(B); GV->setAttributes(AttributeSet::get(Context,Attrs)); } else { @@ -1206,7 +1209,7 @@ } } - AttrBuilder Attrs; + AttrBuilder Attrs(M->getContext()); LocTy BuiltinLoc; std::vector FwdRefAttrGrps; if (parseFnAttributeValuePairs(Attrs, FwdRefAttrGrps, false, BuiltinLoc)) @@ -1235,13 +1238,18 @@ Lex.Lex(); if (parseToken(lltok::equal, "expected '=' here") || - parseToken(lltok::lbrace, "expected '{' here") || - parseFnAttributeValuePairs(NumberedAttrBuilders[VarID], unused, true, - BuiltinLoc) || + parseToken(lltok::lbrace, "expected '{' here")) + return true; + + auto R = NumberedAttrBuilders.find(VarID); + if (R == NumberedAttrBuilders.end()) + R = NumberedAttrBuilders.emplace(VarID, AttrBuilder(M->getContext())).first; + + if (parseFnAttributeValuePairs(R->second, unused, true, BuiltinLoc) || parseToken(lltok::rbrace, "expected end of attribute group")) return true; - if (!NumberedAttrBuilders[VarID].hasAttributes()) + if (!R->second.hasAttributes()) return error(AttrGrpLoc, "attribute group has no attributes"); return false; @@ -2372,11 +2380,12 @@ // parse the argument. LocTy ArgLoc; Type *ArgTy = nullptr; - AttrBuilder ArgAttrs; Value *V; if (parseType(ArgTy, ArgLoc)) return true; + AttrBuilder ArgAttrs(M->getContext()); + if (ArgTy->isMetadataTy()) { if (parseMetadataAsValue(V, PFS)) return true; @@ -2493,7 +2502,7 @@ } else { LocTy TypeLoc = Lex.getLoc(); Type *ArgTy = nullptr; - AttrBuilder Attrs; + AttrBuilder Attrs(M->getContext()); std::string Name; if (parseType(ArgTy) || parseOptionalParamAttrs(Attrs)) @@ -5462,7 +5471,7 @@ unsigned Visibility; unsigned DLLStorageClass; bool DSOLocal; - AttrBuilder RetAttrs; + AttrBuilder RetAttrs(M->getContext()); unsigned CC; bool HasLinkage; Type *RetType = nullptr; @@ -5525,7 +5534,7 @@ SmallVector ArgList; bool IsVarArg; - AttrBuilder FuncAttrs; + AttrBuilder FuncAttrs(M->getContext()); std::vector FwdRefAttrGrps; LocTy BuiltinLoc; std::string Section; @@ -6248,7 +6257,7 @@ /// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue bool LLParser::parseInvoke(Instruction *&Inst, PerFunctionState &PFS) { LocTy CallLoc = Lex.getLoc(); - AttrBuilder RetAttrs, FnAttrs; + AttrBuilder RetAttrs(M->getContext()), FnAttrs(M->getContext()); std::vector FwdRefAttrGrps; LocTy NoBuiltinLoc; unsigned CC; @@ -6558,7 +6567,7 @@ /// '[' LabelList ']' bool LLParser::parseCallBr(Instruction *&Inst, PerFunctionState &PFS) { LocTy CallLoc = Lex.getLoc(); - AttrBuilder RetAttrs, FnAttrs; + AttrBuilder RetAttrs(M->getContext()), FnAttrs(M->getContext()); std::vector FwdRefAttrGrps; LocTy NoBuiltinLoc; unsigned CC; @@ -6975,7 +6984,7 @@ /// OptionalAttrs Type Value ParameterList OptionalAttrs bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS, CallInst::TailCallKind TCK) { - AttrBuilder RetAttrs, FnAttrs; + AttrBuilder RetAttrs(M->getContext()), FnAttrs(M->getContext()); std::vector FwdRefAttrGrps; LocTy BuiltinLoc; unsigned CallAddrSpace; diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -1349,7 +1349,7 @@ return error("Invalid record"); for (unsigned i = 0, e = Record.size(); i != e; i += 2) { - AttrBuilder B; + AttrBuilder B(Context); decodeLLVMAttributesForBitcode(B, Record[i+1]); Attrs.push_back(AttributeList::get(Context, Record[i], B)); } @@ -1591,7 +1591,7 @@ uint64_t GrpID = Record[0]; uint64_t Idx = Record[1]; // Index of the object this attribute refers to. - AttrBuilder B; + AttrBuilder B(Context); for (unsigned i = 2, e = Record.size(); i != e; ++i) { if (Record[i] == 0) { // Enum attribute Attribute::AttrKind Kind; diff --git a/llvm/lib/CodeGen/Analysis.cpp b/llvm/lib/CodeGen/Analysis.cpp --- a/llvm/lib/CodeGen/Analysis.cpp +++ b/llvm/lib/CodeGen/Analysis.cpp @@ -577,8 +577,8 @@ bool &ADS = AllowDifferingSizes ? *AllowDifferingSizes : DummyADS; ADS = true; - AttrBuilder CallerAttrs(F->getAttributes(), AttributeList::ReturnIndex); - AttrBuilder CalleeAttrs(cast(I)->getAttributes(), + AttrBuilder CallerAttrs(F->getContext(), F->getAttributes(), AttributeList::ReturnIndex); + AttrBuilder CalleeAttrs(F->getContext(), cast(I)->getAttributes(), AttributeList::ReturnIndex); // Following attributes are completely benign as far as calling convention diff --git a/llvm/lib/CodeGen/CommandFlags.cpp b/llvm/lib/CodeGen/CommandFlags.cpp --- a/llvm/lib/CodeGen/CommandFlags.cpp +++ b/llvm/lib/CodeGen/CommandFlags.cpp @@ -620,7 +620,7 @@ Function &F) { auto &Ctx = F.getContext(); AttributeList Attrs = F.getAttributes(); - AttrBuilder NewAttrs; + AttrBuilder NewAttrs(Ctx); if (!CPU.empty() && !F.hasFnAttribute("target-cpu")) NewAttrs.addAttribute("target-cpu", CPU); diff --git a/llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp b/llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp --- a/llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp +++ b/llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp @@ -564,7 +564,7 @@ // the return. Ignore NoAlias and NonNull because they don't affect the // call sequence. AttributeList CallerAttrs = F.getAttributes(); - if (AttrBuilder(CallerAttrs, AttributeList::ReturnIndex) + if (AttrBuilder(F.getContext(), CallerAttrs, AttributeList::ReturnIndex) .removeAttribute(Attribute::NoAlias) .removeAttribute(Attribute::NonNull) .hasAttributes()) diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp --- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp @@ -60,7 +60,7 @@ // Conservatively require the attributes of the call to match those of // the return. Ignore following attributes because they don't affect the // call sequence. - AttrBuilder CallerAttrs(F.getAttributes(), AttributeList::ReturnIndex); + AttrBuilder CallerAttrs(F.getContext(), F.getAttributes(), AttributeList::ReturnIndex); for (const auto &Attr : {Attribute::Alignment, Attribute::Dereferenceable, Attribute::DereferenceableOrNull, Attribute::NoAlias, Attribute::NonNull}) diff --git a/llvm/lib/IR/Attributes.cpp b/llvm/lib/IR/Attributes.cpp --- a/llvm/lib/IR/Attributes.cpp +++ b/llvm/lib/IR/Attributes.cpp @@ -607,14 +607,14 @@ AttributeSet AttributeSet::addAttribute(LLVMContext &C, Attribute::AttrKind Kind) const { if (hasAttribute(Kind)) return *this; - AttrBuilder B; + AttrBuilder B(C); B.addAttribute(Kind); return addAttributes(C, AttributeSet::get(C, B)); } AttributeSet AttributeSet::addAttribute(LLVMContext &C, StringRef Kind, StringRef Value) const { - AttrBuilder B; + AttrBuilder B(C); B.addAttribute(Kind, Value); return addAttributes(C, AttributeSet::get(C, B)); } @@ -627,7 +627,7 @@ if (!AS.hasAttributes()) return *this; - AttrBuilder B(AS); + AttrBuilder B(C, AS); for (const auto &I : *this) B.addAttribute(I); @@ -637,7 +637,7 @@ AttributeSet AttributeSet::removeAttribute(LLVMContext &C, Attribute::AttrKind Kind) const { if (!hasAttribute(Kind)) return *this; - AttrBuilder B(*this); + AttrBuilder B(C, *this); B.removeAttribute(Kind); return get(C, B); } @@ -645,14 +645,14 @@ AttributeSet AttributeSet::removeAttribute(LLVMContext &C, StringRef Kind) const { if (!hasAttribute(Kind)) return *this; - AttrBuilder B(*this); + AttrBuilder B(C, *this); B.removeAttribute(Kind); return get(C, B); } AttributeSet AttributeSet::removeAttributes(LLVMContext &C, const AttributeMask &Attrs) const { - AttrBuilder B(*this); + AttrBuilder B(C, *this); // If there is nothing to remove, directly return the original set. if (!B.overlaps(Attrs)) return *this; @@ -836,7 +836,7 @@ // Add target-dependent (string) attributes. for (const auto &TDA : B.td_attrs()) - Attrs.emplace_back(Attribute::get(C, TDA.first, TDA.second)); + Attrs.push_back(TDA); return getSorted(C, Attrs); } @@ -1194,9 +1194,9 @@ SmallVector NewAttrSets(MaxSize); for (unsigned I = 0; I < MaxSize; ++I) { - AttrBuilder CurBuilder; + AttrBuilder CurBuilder(C); for (const auto &List : Attrs) - CurBuilder.merge(List.getAttributes(I - 1)); + CurBuilder.merge(AttrBuilder(C, List.getAttributes(I - 1))); NewAttrSets[I] = AttributeSet::get(C, CurBuilder); } @@ -1218,14 +1218,14 @@ AttributeList AttributeList::addAttributeAtIndex(LLVMContext &C, unsigned Index, StringRef Kind, StringRef Value) const { - AttrBuilder B; + AttrBuilder B(C); B.addAttribute(Kind, Value); return addAttributesAtIndex(C, Index, B); } AttributeList AttributeList::addAttributeAtIndex(LLVMContext &C, unsigned Index, Attribute A) const { - AttrBuilder B; + AttrBuilder B(C); B.addAttribute(A); return addAttributesAtIndex(C, Index, B); } @@ -1259,7 +1259,7 @@ "Attempt to change alignment!"); #endif - AttrBuilder Merged(getAttributes(Index)); + AttrBuilder Merged(C, getAttributes(Index)); Merged.merge(B); return setAttributesAtIndex(C, Index, AttributeSet::get(C, Merged)); } @@ -1276,7 +1276,7 @@ for (unsigned ArgNo : ArgNos) { unsigned Index = attrIdxToArrayIdx(ArgNo + FirstArgIndex); - AttrBuilder B(AttrSets[Index]); + AttrBuilder B(C, AttrSets[Index]); B.addAttribute(A); AttrSets[Index] = AttributeSet::get(C, B); } @@ -1339,7 +1339,7 @@ AttributeList AttributeList::addDereferenceableRetAttr(LLVMContext &C, uint64_t Bytes) const { - AttrBuilder B; + AttrBuilder B(C); B.addDereferenceableAttr(Bytes); return addRetAttributes(C, B); } @@ -1347,7 +1347,7 @@ AttributeList AttributeList::addDereferenceableParamAttr(LLVMContext &C, unsigned Index, uint64_t Bytes) const { - AttrBuilder B; + AttrBuilder B(C); B.addDereferenceableAttr(Bytes); return addParamAttributes(C, Index, B); } @@ -1355,7 +1355,7 @@ AttributeList AttributeList::addDereferenceableOrNullParamAttr(LLVMContext &C, unsigned Index, uint64_t Bytes) const { - AttrBuilder B; + AttrBuilder B(C); B.addDereferenceableOrNullAttr(Bytes); return addParamAttributes(C, Index, B); } @@ -1364,7 +1364,7 @@ AttributeList::addAllocSizeParamAttr(LLVMContext &C, unsigned Index, unsigned ElemSizeArg, const Optional &NumElemsArg) { - AttrBuilder B; + AttrBuilder B(C); B.addAllocSizeAttr(ElemSizeArg, NumElemsArg); return addParamAttributes(C, Index, B); } @@ -1549,13 +1549,14 @@ //===----------------------------------------------------------------------===// // FIXME: Remove this ctor, use AttributeSet. -AttrBuilder::AttrBuilder(AttributeList AL, unsigned Index) { +AttrBuilder::AttrBuilder(LLVMContext &Ctx, AttributeList AL, unsigned Index) + : Ctx(Ctx) { AttributeSet AS = AL.getAttributes(Index); for (const auto &A : AS) addAttribute(A); } -AttrBuilder::AttrBuilder(AttributeSet AS) { +AttrBuilder::AttrBuilder(LLVMContext &Ctx, AttributeSet AS) : Ctx(Ctx) { for (const auto &A : AS) addAttribute(A); } @@ -1581,9 +1582,22 @@ return None; } +struct StringAttributeComparator { + bool operator()(Attribute A0, Attribute A1) const { + return A0.getKindAsString() < A1.getKindAsString(); + } + bool operator()(Attribute A0, StringRef Kind) const { + return A0.getKindAsString() < Kind; + } +}; + AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) { if (Attr.isStringAttribute()) { - addAttribute(Attr.getKindAsString(), Attr.getValueAsString()); + auto It = lower_bound(TargetDepAttrs, Attr, StringAttributeComparator()); + if (It != TargetDepAttrs.end() && It->hasAttribute(Attr.getKindAsString())) + std::swap(*It, Attr); + else + TargetDepAttrs.insert(It, Attr); return *this; } @@ -1599,8 +1613,7 @@ } AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) { - TargetDepAttrs[A] = V; - return *this; + return addAttribute(Attribute::get(Ctx, A, V)); } AttrBuilder &AttrBuilder::removeAttributes(AttributeList AL, uint64_t Index) { @@ -1621,7 +1634,9 @@ } AttrBuilder &AttrBuilder::removeAttribute(StringRef A) { - TargetDepAttrs.erase(A); + auto It = lower_bound(TargetDepAttrs, A, StringAttributeComparator()); + if (It != TargetDepAttrs.end() && It->hasAttribute(A)) + TargetDepAttrs.erase(It); return *this; } @@ -1753,14 +1768,14 @@ Attrs |= B.Attrs; + // TODO: could merge both lists in one loop for (const auto &I : B.td_attrs()) - TargetDepAttrs[I.first] = I.second; + addAttribute(I); return *this; } AttrBuilder &AttrBuilder::remove(const AttributeMask &AM) { - // FIXME: What if both have an int/type attribute, but they don't match?! for (unsigned Index = 0; Index < Attribute::NumIntAttrKinds; ++Index) if (AM.contains((Attribute::AttrKind)Index)) IntAttrs[Index] = 0; @@ -1771,8 +1786,8 @@ Attrs &= ~AM.attrs(); - for (const auto &I : AM.td_attrs()) - TargetDepAttrs.erase(I); + erase_if(TargetDepAttrs, + [&AM](Attribute A) { return AM.contains(A.getKindAsString()); }); return *this; } @@ -1784,13 +1799,14 @@ // Then check if any target dependent ones do. for (const auto &I : td_attrs()) - if (AM.contains(I.first)) + if (AM.contains(I.getKindAsString())) return true; return false; } bool AttrBuilder::contains(StringRef A) const { - return TargetDepAttrs.find(A) != TargetDepAttrs.end(); + auto It = lower_bound(TargetDepAttrs, A, StringAttributeComparator()); + return It != TargetDepAttrs.end() && It->hasAttribute(A); } bool AttrBuilder::hasAttributes() const { @@ -1818,14 +1834,8 @@ } bool AttrBuilder::operator==(const AttrBuilder &B) const { - if (Attrs != B.Attrs) - return false; - - for (const auto &TDA : TargetDepAttrs) - if (B.TargetDepAttrs.find(TDA.first) == B.TargetDepAttrs.end()) - return false; - - return IntAttrs == B.IntAttrs && TypeAttrs == B.TypeAttrs; + return Attrs == B.Attrs && IntAttrs == B.IntAttrs && + TypeAttrs == B.TypeAttrs && TargetDepAttrs == B.TargetDepAttrs; } //===----------------------------------------------------------------------===// diff --git a/llvm/lib/IR/AutoUpgrade.cpp b/llvm/lib/IR/AutoUpgrade.cpp --- a/llvm/lib/IR/AutoUpgrade.cpp +++ b/llvm/lib/IR/AutoUpgrade.cpp @@ -4587,9 +4587,9 @@ StringRef FramePointer; if (B.contains("no-frame-pointer-elim")) { // The value can be "true" or "false". - for (const auto &I : B.td_attrs()) - if (I.first == "no-frame-pointer-elim") - FramePointer = I.second == "true" ? "all" : "none"; + for (const auto &A : B.td_attrs()) + if (A.getKindAsString() == "no-frame-pointer-elim") + FramePointer = A.getValueAsString() == "true" ? "all" : "none"; B.removeAttribute("no-frame-pointer-elim"); } if (B.contains("no-frame-pointer-elim-non-leaf")) { @@ -4604,9 +4604,9 @@ if (B.contains("null-pointer-is-valid")) { // The value can be "true" or "false". bool NullPointerIsValid = false; - for (const auto &I : B.td_attrs()) - if (I.first == "null-pointer-is-valid") - NullPointerIsValid = I.second == "true"; + for (const auto &A : B.td_attrs()) + if (A.getKindAsString() == "null-pointer-is-valid") + NullPointerIsValid = A.getValueAsString() == "true"; B.removeAttribute("null-pointer-is-valid"); if (NullPointerIsValid) B.addAttribute(Attribute::NullPointerIsValid); diff --git a/llvm/lib/IR/Function.cpp b/llvm/lib/IR/Function.cpp --- a/llvm/lib/IR/Function.cpp +++ b/llvm/lib/IR/Function.cpp @@ -340,7 +340,7 @@ unsigned AddrSpace, const Twine &N, Module *M) { auto *F = new Function(Ty, Linkage, AddrSpace, N, M); - AttrBuilder B; + AttrBuilder B(F->getContext()); if (M->getUwtable()) B.addAttribute(Attribute::UWTable); switch (M->getFramePointer()) { diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp --- a/llvm/lib/IR/Verifier.cpp +++ b/llvm/lib/IR/Verifier.cpp @@ -3381,13 +3381,13 @@ return PL->getAddressSpace() == PR->getAddressSpace(); } -static AttrBuilder getParameterABIAttributes(unsigned I, AttributeList Attrs) { +static AttrBuilder getParameterABIAttributes(LLVMContext& C, unsigned I, AttributeList Attrs) { static const Attribute::AttrKind ABIAttrs[] = { Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca, Attribute::InReg, Attribute::StackAlignment, Attribute::SwiftSelf, Attribute::SwiftAsync, Attribute::SwiftError, Attribute::Preallocated, Attribute::ByRef}; - AttrBuilder Copy; + AttrBuilder Copy(C); for (auto AK : ABIAttrs) { Attribute Attr = Attrs.getParamAttrs(I).getAttribute(AK); if (Attr.isValid()) @@ -3450,12 +3450,12 @@ // - Only sret, byval, swiftself, and swiftasync ABI-impacting attributes // are allowed in swifttailcc call for (unsigned I = 0, E = CallerTy->getNumParams(); I != E; ++I) { - AttrBuilder ABIAttrs = getParameterABIAttributes(I, CallerAttrs); + AttrBuilder ABIAttrs = getParameterABIAttributes(F->getContext(), I, CallerAttrs); SmallString<32> Context{CCName, StringRef(" musttail caller")}; verifyTailCCMustTailAttrs(ABIAttrs, Context); } for (unsigned I = 0, E = CalleeTy->getNumParams(); I != E; ++I) { - AttrBuilder ABIAttrs = getParameterABIAttributes(I, CalleeAttrs); + AttrBuilder ABIAttrs = getParameterABIAttributes(F->getContext(), I, CalleeAttrs); SmallString<32> Context{CCName, StringRef(" musttail callee")}; verifyTailCCMustTailAttrs(ABIAttrs, Context); } @@ -3482,8 +3482,8 @@ // - All ABI-impacting function attributes, such as sret, byval, inreg, // returned, preallocated, and inalloca, must match. for (unsigned I = 0, E = CallerTy->getNumParams(); I != E; ++I) { - AttrBuilder CallerABIAttrs = getParameterABIAttributes(I, CallerAttrs); - AttrBuilder CalleeABIAttrs = getParameterABIAttributes(I, CalleeAttrs); + AttrBuilder CallerABIAttrs = getParameterABIAttributes(F->getContext(), I, CallerAttrs); + AttrBuilder CalleeABIAttrs = getParameterABIAttributes(F->getContext(), I, CalleeAttrs); Assert(CallerABIAttrs == CalleeABIAttrs, "cannot guarantee tail call due to mismatched ABI impacting " "function attributes", diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp --- a/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp @@ -455,12 +455,12 @@ // Tell the linker that this function is expected to be imported from the // 'env' module. if (!F->hasFnAttribute("wasm-import-module")) { - llvm::AttrBuilder B; + llvm::AttrBuilder B(M->getContext()); B.addAttribute("wasm-import-module", "env"); F->addFnAttrs(B); } if (!F->hasFnAttribute("wasm-import-name")) { - llvm::AttrBuilder B; + llvm::AttrBuilder B(M->getContext()); B.addAttribute("wasm-import-name", F->getName()); F->addFnAttrs(B); } @@ -548,7 +548,7 @@ for (unsigned I = 0, E = CI->arg_size(); I < E; ++I) ArgAttributes.push_back(InvokeAL.getParamAttrs(I)); - AttrBuilder FnAttrs(InvokeAL.getFnAttrs()); + AttrBuilder FnAttrs(CI->getContext(), InvokeAL.getFnAttrs()); if (FnAttrs.contains(Attribute::AllocSize)) { // The allocsize attribute (if any) referes to parameters by index and needs // to be adjusted. diff --git a/llvm/lib/Transforms/Coroutines/CoroSplit.cpp b/llvm/lib/Transforms/Coroutines/CoroSplit.cpp --- a/llvm/lib/Transforms/Coroutines/CoroSplit.cpp +++ b/llvm/lib/Transforms/Coroutines/CoroSplit.cpp @@ -835,7 +835,7 @@ static void addFramePointerAttrs(AttributeList &Attrs, LLVMContext &Context, unsigned ParamIndex, uint64_t Size, Align Alignment) { - AttrBuilder ParamAttrs; + AttrBuilder ParamAttrs(Context); ParamAttrs.addAttribute(Attribute::NonNull); ParamAttrs.addAttribute(Attribute::NoAlias); ParamAttrs.addAlignmentAttr(Alignment); @@ -845,14 +845,14 @@ static void addAsyncContextAttrs(AttributeList &Attrs, LLVMContext &Context, unsigned ParamIndex) { - AttrBuilder ParamAttrs; + AttrBuilder ParamAttrs(Context); ParamAttrs.addAttribute(Attribute::SwiftAsync); Attrs = Attrs.addParamAttributes(Context, ParamIndex, ParamAttrs); } static void addSwiftSelfAttrs(AttributeList &Attrs, LLVMContext &Context, unsigned ParamIndex) { - AttrBuilder ParamAttrs; + AttrBuilder ParamAttrs(Context); ParamAttrs.addAttribute(Attribute::SwiftSelf); Attrs = Attrs.addParamAttributes(Context, ParamIndex, ParamAttrs); } @@ -929,7 +929,7 @@ case coro::ABI::Switch: // Bootstrap attributes by copying function attributes from the // original function. This should include optimization settings and so on. - NewAttrs = NewAttrs.addFnAttributes(Context, OrigAttrs.getFnAttrs()); + NewAttrs = NewAttrs.addFnAttributes(Context, AttrBuilder(Context, OrigAttrs.getFnAttrs())); addFramePointerAttrs(NewAttrs, Context, 0, Shape.FrameSize, Shape.FrameAlign); @@ -952,7 +952,7 @@ // Transfer the original function's attributes. auto FnAttrs = OrigF.getAttributes().getFnAttrs(); - NewAttrs = NewAttrs.addFnAttributes(Context, FnAttrs); + NewAttrs = NewAttrs.addFnAttributes(Context, AttrBuilder(Context, FnAttrs)); break; } case coro::ABI::Retcon: diff --git a/llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp b/llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp --- a/llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp +++ b/llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp @@ -839,7 +839,7 @@ assert(NRetTy && "No new return type found?"); // The existing function return attributes. - AttrBuilder RAttrs(PAL.getRetAttrs()); + AttrBuilder RAttrs(F->getContext(), PAL.getRetAttrs()); // Remove any incompatible attributes, but only if we removed all return // values. Otherwise, ensure that we don't have any conflicting attributes @@ -890,7 +890,7 @@ // Adjust the call return attributes in case the function was changed to // return void. - AttrBuilder RAttrs(CallPAL.getRetAttrs()); + AttrBuilder RAttrs(F->getContext(), CallPAL.getRetAttrs()); RAttrs.remove(AttributeFuncs::typeIncompatible(NRetTy)); AttributeSet RetAttrs = AttributeSet::get(F->getContext(), RAttrs); @@ -913,7 +913,7 @@ // this is not an expected case anyway ArgAttrVec.push_back(AttributeSet::get( F->getContext(), - AttrBuilder(Attrs).removeAttribute(Attribute::Returned))); + AttrBuilder(F->getContext(), Attrs).removeAttribute(Attribute::Returned))); } else { // Otherwise, use the original attributes. ArgAttrVec.push_back(Attrs); diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp --- a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp @@ -2913,7 +2913,7 @@ } if (!CallerPAL.isEmpty() && !Caller->use_empty()) { - AttrBuilder RAttrs(CallerPAL, AttributeList::ReturnIndex); + AttrBuilder RAttrs(FT->getContext(), CallerPAL, AttributeList::ReturnIndex); if (RAttrs.overlaps(AttributeFuncs::typeIncompatible(NewRetTy))) return false; // Attribute not compatible with transformed value. } @@ -2959,7 +2959,7 @@ if (!CastInst::isBitOrNoopPointerCastable(ActTy, ParamTy, DL)) return false; // Cannot transform this parameter value. - if (AttrBuilder(CallerPAL.getParamAttrs(i)) + if (AttrBuilder(FT->getContext(), CallerPAL.getParamAttrs(i)) .overlaps(AttributeFuncs::typeIncompatible(ParamTy))) return false; // Attribute not compatible with transformed value. @@ -3024,7 +3024,7 @@ ArgAttrs.reserve(NumActualArgs); // Get any return attributes. - AttrBuilder RAttrs(CallerPAL, AttributeList::ReturnIndex); + AttrBuilder RAttrs(FT->getContext(), CallerPAL, AttributeList::ReturnIndex); // If the return value is not being used, the type may not be compatible // with the existing attributes. Wipe out any problematic attributes. @@ -3042,7 +3042,7 @@ // Add any parameter attributes. if (CallerPAL.hasParamAttr(i, Attribute::ByVal)) { - AttrBuilder AB(CallerPAL.getParamAttrs(i)); + AttrBuilder AB(FT->getContext(), CallerPAL.getParamAttrs(i)); AB.addByValAttr(NewArg->getType()->getPointerElementType()); ArgAttrs.push_back(AttributeSet::get(Ctx, AB)); } else diff --git a/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp b/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp --- a/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp +++ b/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp @@ -1367,7 +1367,7 @@ return AL; // Remove the readonly, readnone, and statepoint function attributes. - AttrBuilder FnAttrs = AL.getFnAttrs(); + AttrBuilder FnAttrs(Ctx, AL.getFnAttrs()); for (auto Attr : FnAttrsToStrip) FnAttrs.removeAttribute(Attr); diff --git a/llvm/lib/Transforms/Utils/CallPromotionUtils.cpp b/llvm/lib/Transforms/Utils/CallPromotionUtils.cpp --- a/llvm/lib/Transforms/Utils/CallPromotionUtils.cpp +++ b/llvm/lib/Transforms/Utils/CallPromotionUtils.cpp @@ -500,7 +500,7 @@ CB.setArgOperand(ArgNo, Cast); // Remove any incompatible attributes for the argument. - AttrBuilder ArgAttrs(CallerPAL.getParamAttrs(ArgNo)); + AttrBuilder ArgAttrs(Ctx, CallerPAL.getParamAttrs(ArgNo)); ArgAttrs.remove(AttributeFuncs::typeIncompatible(FormalTy)); // We may have a different byval/inalloca type. @@ -518,7 +518,7 @@ // If the return type of the call site doesn't match that of the callee, cast // the returned value to the appropriate type. // Remove any incompatible return value attribute. - AttrBuilder RAttrs(CallerPAL, AttributeList::ReturnIndex); + AttrBuilder RAttrs(Ctx, CallerPAL, AttributeList::ReturnIndex); if (!CallSiteRetTy->isVoidTy() && CallSiteRetTy != CalleeRetTy) { createRetBitCast(CB, CallSiteRetTy, RetBitCast); RAttrs.remove(AttributeFuncs::typeIncompatible(CalleeRetTy)); diff --git a/llvm/lib/Transforms/Utils/InlineFunction.cpp b/llvm/lib/Transforms/Utils/InlineFunction.cpp --- a/llvm/lib/Transforms/Utils/InlineFunction.cpp +++ b/llvm/lib/Transforms/Utils/InlineFunction.cpp @@ -1185,10 +1185,10 @@ static AttrBuilder IdentifyValidAttributes(CallBase &CB) { - AttrBuilder AB(CB.getAttributes(), AttributeList::ReturnIndex); + AttrBuilder AB(CB.getContext(), CB.getAttributes(), AttributeList::ReturnIndex); if (AB.empty()) return AB; - AttrBuilder Valid; + AttrBuilder Valid(CB.getContext()); // Only allow these white listed attributes to be propagated back to the // callee. This is because other attributes may only be valid on the call // itself, i.e. attributes such as signext and zeroext. diff --git a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp --- a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -602,7 +602,7 @@ Align MemSetAlign = CI->getAttributes().getParamAttrs(0).getAlignment().valueOrOne(); CallInst *NewCI = B.CreateMemSet(Dst, B.getInt8('\0'), Size, MemSetAlign); - AttrBuilder ArgAttrs(CI->getAttributes().getParamAttrs(0)); + AttrBuilder ArgAttrs(CI->getContext(), CI->getAttributes().getParamAttrs(0)); NewCI->setAttributes(NewCI->getAttributes().addParamAttributes( CI->getContext(), 0, ArgAttrs)); copyFlags(*CI, NewCI); diff --git a/llvm/tools/bugpoint/CrashDebugger.cpp b/llvm/tools/bugpoint/CrashDebugger.cpp --- a/llvm/tools/bugpoint/CrashDebugger.cpp +++ b/llvm/tools/bugpoint/CrashDebugger.cpp @@ -354,7 +354,7 @@ // Build up an AttributeList from the attributes we've been given by the // reducer. - AttrBuilder AB; + AttrBuilder AB(M->getContext()); for (auto A : Attrs) AB.addAttribute(A); AttributeList NewAttrs; diff --git a/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp b/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp --- a/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp @@ -141,7 +141,7 @@ AttributeSet convertAttributeRefToAttributeSet(LLVMContext &C, ArrayRef Attributes) { - AttrBuilder B; + AttrBuilder B(C); for (const Attribute *A : Attributes) B.addAttribute(*A); return AttributeSet::get(C, B); diff --git a/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp --- a/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp @@ -24,11 +24,11 @@ Type::getVoidTy(Context), {ArgPtrTy, ArgPtrTy}, false); Function *F = MB.createFunctionDecl(FTy, ""); AttributeSet FnAttrs = AttributeSet::get( - Context, AttrBuilder().addAttribute(Attribute::NoUnwind)); + Context, AttrBuilder(Context).addAttribute(Attribute::NoUnwind)); AttributeSet RetAttrs; // None AttributeSet ArgAttrs[2] = { - AttributeSet::get(Context, AttrBuilder().addStructRetAttr(ArgTy)), - AttributeSet::get(Context, AttrBuilder().addByValAttr(ArgTy)), + AttributeSet::get(Context, AttrBuilder(Context).addStructRetAttr(ArgTy)), + AttributeSet::get(Context, AttrBuilder(Context).addByValAttr(ArgTy)), }; F->setAttributes(AttributeList::get(Context, FnAttrs, RetAttrs, ArgAttrs)); diff --git a/llvm/unittests/IR/AttributesTest.cpp b/llvm/unittests/IR/AttributesTest.cpp --- a/llvm/unittests/IR/AttributesTest.cpp +++ b/llvm/unittests/IR/AttributesTest.cpp @@ -62,9 +62,9 @@ TEST(Attributes, AddAttributes) { LLVMContext C; AttributeList AL; - AttrBuilder B; + AttrBuilder B(C); B.addAttribute(Attribute::NoReturn); - AL = AL.addFnAttributes(C, AttributeSet::get(C, B)); + AL = AL.addFnAttributes(C, AttrBuilder(C, AttributeSet::get(C, B))); EXPECT_TRUE(AL.hasFnAttr(Attribute::NoReturn)); B.clear(); B.addAttribute(Attribute::SExt); @@ -78,12 +78,12 @@ Attribute AlignAttr = Attribute::getWithAlignment(C, Align(8)); Attribute StackAlignAttr = Attribute::getWithStackAlignment(C, Align(32)); - AttrBuilder B_align_readonly; + AttrBuilder B_align_readonly(C); B_align_readonly.addAttribute(AlignAttr); B_align_readonly.addAttribute(Attribute::ReadOnly); AttributeMask B_align; B_align.addAttribute(AlignAttr); - AttrBuilder B_stackalign_optnone; + AttrBuilder B_stackalign_optnone(C); B_stackalign_optnone.addAttribute(StackAlignAttr); B_stackalign_optnone.addAttribute(Attribute::OptimizeNone); AttributeMask B_stackalign; @@ -151,7 +151,7 @@ EXPECT_EQ(Align(8), AL.getParamAlignment(0)); EXPECT_EQ(Align(32), AL.getParamAlignment(1)); - AttrBuilder B; + AttrBuilder B(C); B.addAttribute(Attribute::NonNull); B.addAlignmentAttr(8); AL = AL.addParamAttributes(C, 0, B); diff --git a/llvm/unittests/IR/InstructionsTest.cpp b/llvm/unittests/IR/InstructionsTest.cpp --- a/llvm/unittests/IR/InstructionsTest.cpp +++ b/llvm/unittests/IR/InstructionsTest.cpp @@ -614,7 +614,7 @@ // Test cloning an attribute. { - AttrBuilder AB; + AttrBuilder AB(C); AB.addAttribute(Attribute::ReadOnly); Call->setAttributes( AttributeList::get(C, AttributeList::FunctionIndex, AB)); @@ -633,7 +633,7 @@ std::unique_ptr Call( CallInst::Create(FnTy, Callee, Args, OldBundle, "result")); Call->setTailCallKind(CallInst::TailCallKind::TCK_NoTail); - AttrBuilder AB; + AttrBuilder AB(C); AB.addAttribute(Attribute::Cold); Call->setAttributes(AttributeList::get(C, AttributeList::FunctionIndex, AB)); Call->setDebugLoc(DebugLoc(MDNode::get(C, None))); @@ -662,7 +662,7 @@ std::unique_ptr Invoke( InvokeInst::Create(FnTy, Callee, NormalDest.get(), UnwindDest.get(), Args, OldBundle, "result")); - AttrBuilder AB; + AttrBuilder AB(C); AB.addAttribute(Attribute::Cold); Invoke->setAttributes( AttributeList::get(C, AttributeList::FunctionIndex, AB)); diff --git a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp --- a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp +++ b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp @@ -753,7 +753,7 @@ return func.emitError( "llvm.align attribute attached to LLVM non-pointer argument"); llvmArg.addAttrs( - llvm::AttrBuilder().addAlignmentAttr(llvm::Align(attr.getInt()))); + llvm::AttrBuilder(llvmArg.getContext()).addAlignmentAttr(llvm::Align(attr.getInt()))); } if (auto attr = func.getArgAttrOfType(argIdx, "llvm.sret")) { @@ -761,7 +761,7 @@ if (!argTy.isa()) return func.emitError( "llvm.sret attribute attached to LLVM non-pointer argument"); - llvmArg.addAttrs(llvm::AttrBuilder().addStructRetAttr( + llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext()).addStructRetAttr( llvmArg.getType()->getPointerElementType())); } @@ -770,7 +770,7 @@ if (!argTy.isa()) return func.emitError( "llvm.byval attribute attached to LLVM non-pointer argument"); - llvmArg.addAttrs(llvm::AttrBuilder().addByValAttr( + llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext()).addByValAttr( llvmArg.getType()->getPointerElementType())); }