diff options
| author | shadchin <shadchin@yandex-team.ru> | 2022-02-10 16:44:30 +0300 |
|---|---|---|
| committer | Daniil Cherednik <dcherednik@yandex-team.ru> | 2022-02-10 16:44:30 +0300 |
| commit | 2598ef1d0aee359b4b6d5fdd1758916d5907d04f (patch) | |
| tree | 012bb94d777798f1f56ac1cec429509766d05181 /contrib/libs/llvm12/lib/IR | |
| parent | 6751af0b0c1b952fede40b19b71da8025b5d8bcf (diff) | |
| download | ydb-2598ef1d0aee359b4b6d5fdd1758916d5907d04f.tar.gz | |
Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.
Diffstat (limited to 'contrib/libs/llvm12/lib/IR')
53 files changed, 3661 insertions, 3661 deletions
diff --git a/contrib/libs/llvm12/lib/IR/AsmWriter.cpp b/contrib/libs/llvm12/lib/IR/AsmWriter.cpp index 69abf8769e..536f500dc6 100644 --- a/contrib/libs/llvm12/lib/IR/AsmWriter.cpp +++ b/contrib/libs/llvm12/lib/IR/AsmWriter.cpp @@ -116,15 +116,15 @@ struct OrderMap { } // end anonymous namespace -/// Look for a value that might be wrapped as metadata, e.g. a value in a -/// metadata operand. Returns the input value as-is if it is not wrapped. -static const Value *skipMetadataWrapper(const Value *V) { - if (const auto *MAV = dyn_cast<MetadataAsValue>(V)) - if (const auto *VAM = dyn_cast<ValueAsMetadata>(MAV->getMetadata())) - return VAM->getValue(); - return V; -} - +/// Look for a value that might be wrapped as metadata, e.g. a value in a +/// metadata operand. Returns the input value as-is if it is not wrapped. +static const Value *skipMetadataWrapper(const Value *V) { + if (const auto *MAV = dyn_cast<MetadataAsValue>(V)) + if (const auto *VAM = dyn_cast<ValueAsMetadata>(MAV->getMetadata())) + return VAM->getValue(); + return V; +} + static void orderValue(const Value *V, OrderMap &OM) { if (OM.lookup(V).first) return; @@ -174,12 +174,12 @@ static OrderMap orderModule(const Module *M) { for (const BasicBlock &BB : F) { orderValue(&BB, OM); for (const Instruction &I : BB) { - for (const Value *Op : I.operands()) { - Op = skipMetadataWrapper(Op); + for (const Value *Op : I.operands()) { + Op = skipMetadataWrapper(Op); if ((isa<Constant>(*Op) && !isa<GlobalValue>(*Op)) || isa<InlineAsm>(*Op)) orderValue(Op, OM); - } + } orderValue(&I, OM); } } @@ -293,11 +293,11 @@ static UseListOrderStack predictUseListOrder(const Module *M) { predictValueUseListOrder(&A, &F, OM, Stack); for (const BasicBlock &BB : F) for (const Instruction &I : BB) - for (const Value *Op : I.operands()) { - Op = skipMetadataWrapper(Op); + for (const Value *Op : I.operands()) { + Op = skipMetadataWrapper(Op); if (isa<Constant>(*Op) || isa<InlineAsm>(*Op)) // Visit GlobalValues. predictValueUseListOrder(Op, &F, OM, Stack); - } + } for (const BasicBlock &BB : F) for (const Instruction &I : BB) predictValueUseListOrder(&I, &F, OM, Stack); @@ -399,7 +399,7 @@ static void PrintCallingConv(unsigned cc, raw_ostream &Out) { case CallingConv::AMDGPU_PS: Out << "amdgpu_ps"; break; case CallingConv::AMDGPU_CS: Out << "amdgpu_cs"; break; case CallingConv::AMDGPU_KERNEL: Out << "amdgpu_kernel"; break; - case CallingConv::AMDGPU_Gfx: Out << "amdgpu_gfx"; break; + case CallingConv::AMDGPU_Gfx: Out << "amdgpu_gfx"; break; } } @@ -609,7 +609,7 @@ void TypePrinting::print(Type *Ty, raw_ostream &OS) { case Type::LabelTyID: OS << "label"; return; case Type::MetadataTyID: OS << "metadata"; return; case Type::X86_MMXTyID: OS << "x86_mmx"; return; - case Type::X86_AMXTyID: OS << "x86_amx"; return; + case Type::X86_AMXTyID: OS << "x86_amx"; return; case Type::TokenTyID: OS << "token"; return; case Type::IntegerTyID: OS << 'i' << cast<IntegerType>(Ty)->getBitWidth(); @@ -669,9 +669,9 @@ void TypePrinting::print(Type *Ty, raw_ostream &OS) { VectorType *PTy = cast<VectorType>(Ty); ElementCount EC = PTy->getElementCount(); OS << "<"; - if (EC.isScalable()) + if (EC.isScalable()) OS << "vscale x "; - OS << EC.getKnownMinValue() << " x "; + OS << EC.getKnownMinValue() << " x "; print(PTy->getElementType(), OS); OS << '>'; return; @@ -1368,8 +1368,8 @@ static void WriteConstantInternal(raw_ostream &Out, const Constant *CV, // "Inf" or NaN, that atof will accept, but the lexer will not. Check // that the string matches the "[-+]?[0-9]" regex. // - assert((isDigit(StrVal[0]) || ((StrVal[0] == '-' || StrVal[0] == '+') && - isDigit(StrVal[1]))) && + assert((isDigit(StrVal[0]) || ((StrVal[0] == '-' || StrVal[0] == '+') && + isDigit(StrVal[1]))) && "[-+]?[0-9] regex does not match!"); // Reparse stringized version! if (APFloat(APFloat::IEEEdouble(), StrVal).convertToDouble() == Val) { @@ -1385,19 +1385,19 @@ static void WriteConstantInternal(raw_ostream &Out, const Constant *CV, "assuming that double is 64 bits!"); APFloat apf = APF; // Floats are represented in ASCII IR as double, convert. - // FIXME: We should allow 32-bit hex float and remove this. - if (!isDouble) { - // A signaling NaN is quieted on conversion, so we need to recreate the - // expected value after convert (quiet bit of the payload is clear). - bool IsSNAN = apf.isSignaling(); + // FIXME: We should allow 32-bit hex float and remove this. + if (!isDouble) { + // A signaling NaN is quieted on conversion, so we need to recreate the + // expected value after convert (quiet bit of the payload is clear). + bool IsSNAN = apf.isSignaling(); apf.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, - &ignored); - if (IsSNAN) { - APInt Payload = apf.bitcastToAPInt(); - apf = APFloat::getSNaN(APFloat::IEEEdouble(), apf.isNegative(), - &Payload); - } - } + &ignored); + if (IsSNAN) { + APInt Payload = apf.bitcastToAPInt(); + apf = APFloat::getSNaN(APFloat::IEEEdouble(), apf.isNegative(), + &Payload); + } + } Out << format_hex(apf.bitcastToAPInt().getZExtValue(), 0, /*Upper=*/true); return; } @@ -1455,13 +1455,13 @@ static void WriteConstantInternal(raw_ostream &Out, const Constant *CV, return; } - if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV)) { - Out << "dso_local_equivalent "; - WriteAsOperandInternal(Out, Equiv->getGlobalValue(), &TypePrinter, Machine, - Context); - return; - } - + if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV)) { + Out << "dso_local_equivalent "; + WriteAsOperandInternal(Out, Equiv->getGlobalValue(), &TypePrinter, Machine, + Context); + return; + } + if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { Type *ETy = CA->getType()->getElementType(); Out << '['; @@ -1540,7 +1540,7 @@ static void WriteConstantInternal(raw_ostream &Out, const Constant *CV, } if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) { - auto *CVVTy = cast<FixedVectorType>(CV->getType()); + auto *CVVTy = cast<FixedVectorType>(CV->getType()); Type *ETy = CVVTy->getElementType(); Out << '<'; TypePrinter.print(ETy, Out); @@ -1568,11 +1568,11 @@ static void WriteConstantInternal(raw_ostream &Out, const Constant *CV, return; } - if (isa<PoisonValue>(CV)) { - Out << "poison"; - return; - } - + if (isa<PoisonValue>(CV)) { + Out << "poison"; + return; + } + if (isa<UndefValue>(CV)) { Out << "undef"; return; @@ -1923,57 +1923,57 @@ static void writeDISubrange(raw_ostream &Out, const DISubrange *N, Out << ")"; } -static void writeDIGenericSubrange(raw_ostream &Out, const DIGenericSubrange *N, - TypePrinting *TypePrinter, - SlotTracker *Machine, - const Module *Context) { - Out << "!DIGenericSubrange("; - MDFieldPrinter Printer(Out, TypePrinter, Machine, Context); - - auto IsConstant = [&](Metadata *Bound) -> bool { - if (auto *BE = dyn_cast_or_null<DIExpression>(Bound)) { - return BE->isSignedConstant(); - } - return false; - }; - - auto GetConstant = [&](Metadata *Bound) -> int64_t { - assert(IsConstant(Bound) && "Expected constant"); - auto *BE = dyn_cast_or_null<DIExpression>(Bound); - return static_cast<int64_t>(BE->getElement(1)); - }; - - auto *Count = N->getRawCountNode(); - if (IsConstant(Count)) - Printer.printInt("count", GetConstant(Count), - /* ShouldSkipZero */ false); - else - Printer.printMetadata("count", Count, /*ShouldSkipNull */ true); - - auto *LBound = N->getRawLowerBound(); - if (IsConstant(LBound)) - Printer.printInt("lowerBound", GetConstant(LBound), - /* ShouldSkipZero */ false); - else - Printer.printMetadata("lowerBound", LBound, /*ShouldSkipNull */ true); - - auto *UBound = N->getRawUpperBound(); - if (IsConstant(UBound)) - Printer.printInt("upperBound", GetConstant(UBound), - /* ShouldSkipZero */ false); - else - Printer.printMetadata("upperBound", UBound, /*ShouldSkipNull */ true); - - auto *Stride = N->getRawStride(); - if (IsConstant(Stride)) - Printer.printInt("stride", GetConstant(Stride), - /* ShouldSkipZero */ false); - else - Printer.printMetadata("stride", Stride, /*ShouldSkipNull */ true); - - Out << ")"; -} - +static void writeDIGenericSubrange(raw_ostream &Out, const DIGenericSubrange *N, + TypePrinting *TypePrinter, + SlotTracker *Machine, + const Module *Context) { + Out << "!DIGenericSubrange("; + MDFieldPrinter Printer(Out, TypePrinter, Machine, Context); + + auto IsConstant = [&](Metadata *Bound) -> bool { + if (auto *BE = dyn_cast_or_null<DIExpression>(Bound)) { + return BE->isSignedConstant(); + } + return false; + }; + + auto GetConstant = [&](Metadata *Bound) -> int64_t { + assert(IsConstant(Bound) && "Expected constant"); + auto *BE = dyn_cast_or_null<DIExpression>(Bound); + return static_cast<int64_t>(BE->getElement(1)); + }; + + auto *Count = N->getRawCountNode(); + if (IsConstant(Count)) + Printer.printInt("count", GetConstant(Count), + /* ShouldSkipZero */ false); + else + Printer.printMetadata("count", Count, /*ShouldSkipNull */ true); + + auto *LBound = N->getRawLowerBound(); + if (IsConstant(LBound)) + Printer.printInt("lowerBound", GetConstant(LBound), + /* ShouldSkipZero */ false); + else + Printer.printMetadata("lowerBound", LBound, /*ShouldSkipNull */ true); + + auto *UBound = N->getRawUpperBound(); + if (IsConstant(UBound)) + Printer.printInt("upperBound", GetConstant(UBound), + /* ShouldSkipZero */ false); + else + Printer.printMetadata("upperBound", UBound, /*ShouldSkipNull */ true); + + auto *Stride = N->getRawStride(); + if (IsConstant(Stride)) + Printer.printInt("stride", GetConstant(Stride), + /* ShouldSkipZero */ false); + else + Printer.printMetadata("stride", Stride, /*ShouldSkipNull */ true); + + Out << ")"; +} + static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N, TypePrinting *, SlotTracker *, const Module *) { Out << "!DIEnumerator("; @@ -2001,23 +2001,23 @@ static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N, Out << ")"; } -static void writeDIStringType(raw_ostream &Out, const DIStringType *N, - TypePrinting *TypePrinter, SlotTracker *Machine, - const Module *Context) { - Out << "!DIStringType("; - MDFieldPrinter Printer(Out, TypePrinter, Machine, Context); - if (N->getTag() != dwarf::DW_TAG_string_type) - Printer.printTag(N); - Printer.printString("name", N->getName()); - Printer.printMetadata("stringLength", N->getRawStringLength()); - Printer.printMetadata("stringLengthExpression", N->getRawStringLengthExp()); - Printer.printInt("size", N->getSizeInBits()); - Printer.printInt("align", N->getAlignInBits()); - Printer.printDwarfEnum("encoding", N->getEncoding(), - dwarf::AttributeEncodingString); - Out << ")"; -} - +static void writeDIStringType(raw_ostream &Out, const DIStringType *N, + TypePrinting *TypePrinter, SlotTracker *Machine, + const Module *Context) { + Out << "!DIStringType("; + MDFieldPrinter Printer(Out, TypePrinter, Machine, Context); + if (N->getTag() != dwarf::DW_TAG_string_type) + Printer.printTag(N); + Printer.printString("name", N->getName()); + Printer.printMetadata("stringLength", N->getRawStringLength()); + Printer.printMetadata("stringLengthExpression", N->getRawStringLengthExp()); + Printer.printInt("size", N->getSizeInBits()); + Printer.printInt("align", N->getAlignInBits()); + Printer.printDwarfEnum("encoding", N->getEncoding(), + dwarf::AttributeEncodingString); + Out << ")"; +} + static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context) { @@ -2064,13 +2064,13 @@ static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N, Printer.printString("identifier", N->getIdentifier()); Printer.printMetadata("discriminator", N->getRawDiscriminator()); Printer.printMetadata("dataLocation", N->getRawDataLocation()); - Printer.printMetadata("associated", N->getRawAssociated()); - Printer.printMetadata("allocated", N->getRawAllocated()); - if (auto *RankConst = N->getRankConst()) - Printer.printInt("rank", RankConst->getSExtValue(), - /* ShouldSkipZero */ false); - else - Printer.printMetadata("rank", N->getRawRank(), /*ShouldSkipNull */ true); + Printer.printMetadata("associated", N->getRawAssociated()); + Printer.printMetadata("allocated", N->getRawAllocated()); + if (auto *RankConst = N->getRankConst()) + Printer.printInt("rank", RankConst->getSExtValue(), + /* ShouldSkipZero */ false); + else + Printer.printMetadata("rank", N->getRawRank(), /*ShouldSkipNull */ true); Out << ")"; } @@ -2245,7 +2245,7 @@ static void writeDIModule(raw_ostream &Out, const DIModule *N, Printer.printString("apinotes", N->getAPINotesFile()); Printer.printMetadata("file", N->getRawFile()); Printer.printInt("line", N->getLineNo()); - Printer.printBool("isDecl", N->getIsDecl(), /* Default */ false); + Printer.printBool("isDecl", N->getIsDecl(), /* Default */ false); Out << ")"; } @@ -3197,7 +3197,7 @@ void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) { printTypeIdInfo(*TIdInfo); auto PrintRange = [&](const ConstantRange &Range) { - Out << "[" << Range.getSignedMin() << ", " << Range.getSignedMax() << "]"; + Out << "[" << Range.getSignedMin() << ", " << Range.getSignedMax() << "]"; }; if (!FS->paramAccesses().empty()) { @@ -3213,7 +3213,7 @@ void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) { FieldSeparator IFS; for (auto &Call : PS.Calls) { Out << IFS; - Out << "(callee: ^" << Machine.getGUIDSlot(Call.Callee.getGUID()); + Out << "(callee: ^" << Machine.getGUIDSlot(Call.Callee.getGUID()); Out << ", param: " << Call.ParamNo; Out << ", offset: "; PrintRange(Call.Offsets); @@ -4379,17 +4379,17 @@ void AssemblyWriter::writeAttribute(const Attribute &Attr, bool InAttrGroup) { } assert((Attr.hasAttribute(Attribute::ByVal) || - Attr.hasAttribute(Attribute::StructRet) || - Attr.hasAttribute(Attribute::ByRef) || + Attr.hasAttribute(Attribute::StructRet) || + Attr.hasAttribute(Attribute::ByRef) || Attr.hasAttribute(Attribute::Preallocated)) && "unexpected type attr"); if (Attr.hasAttribute(Attribute::ByVal)) { Out << "byval"; - } else if (Attr.hasAttribute(Attribute::StructRet)) { - Out << "sret"; - } else if (Attr.hasAttribute(Attribute::ByRef)) { - Out << "byref"; + } else if (Attr.hasAttribute(Attribute::StructRet)) { + Out << "sret"; + } else if (Attr.hasAttribute(Attribute::ByRef)) { + Out << "byref"; } else { Out << "preallocated"; } @@ -4482,7 +4482,7 @@ void Function::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW, void BasicBlock::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW, bool ShouldPreserveUseListOrder, bool IsForDebug) const { - SlotTracker SlotTable(this->getParent()); + SlotTracker SlotTable(this->getParent()); formatted_raw_ostream OS(ROS); AssemblyWriter W(OS, SlotTable, this->getModule(), AAW, IsForDebug, diff --git a/contrib/libs/llvm12/lib/IR/Assumptions.cpp b/contrib/libs/llvm12/lib/IR/Assumptions.cpp index 1bd8b7f51e..8e6ee41993 100644 --- a/contrib/libs/llvm12/lib/IR/Assumptions.cpp +++ b/contrib/libs/llvm12/lib/IR/Assumptions.cpp @@ -1,36 +1,36 @@ -//===- Assumptions.cpp ------ Collection of helpers for assumptions -------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -//===----------------------------------------------------------------------===// - -#include "llvm/IR/Assumptions.h" -#include "llvm/IR/Attributes.h" -#include "llvm/IR/Function.h" - -using namespace llvm; - -bool llvm::hasAssumption(Function &F, - const KnownAssumptionString &AssumptionStr) { - const Attribute &A = F.getFnAttribute(AssumptionAttrKey); - if (!A.isValid()) - return false; - assert(A.isStringAttribute() && "Expected a string attribute!"); - - SmallVector<StringRef, 8> Strings; - A.getValueAsString().split(Strings, ","); - - return llvm::any_of(Strings, [=](StringRef Assumption) { - return Assumption == AssumptionStr; - }); -} - -StringSet<> llvm::KnownAssumptionStrings({ - "omp_no_openmp", // OpenMP 5.1 - "omp_no_openmp_routines", // OpenMP 5.1 - "omp_no_parallelism", // OpenMP 5.1 -}); +//===- Assumptions.cpp ------ Collection of helpers for assumptions -------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +//===----------------------------------------------------------------------===// + +#include "llvm/IR/Assumptions.h" +#include "llvm/IR/Attributes.h" +#include "llvm/IR/Function.h" + +using namespace llvm; + +bool llvm::hasAssumption(Function &F, + const KnownAssumptionString &AssumptionStr) { + const Attribute &A = F.getFnAttribute(AssumptionAttrKey); + if (!A.isValid()) + return false; + assert(A.isStringAttribute() && "Expected a string attribute!"); + + SmallVector<StringRef, 8> Strings; + A.getValueAsString().split(Strings, ","); + + return llvm::any_of(Strings, [=](StringRef Assumption) { + return Assumption == AssumptionStr; + }); +} + +StringSet<> llvm::KnownAssumptionStrings({ + "omp_no_openmp", // OpenMP 5.1 + "omp_no_openmp_routines", // OpenMP 5.1 + "omp_no_parallelism", // OpenMP 5.1 +}); diff --git a/contrib/libs/llvm12/lib/IR/AttributeImpl.h b/contrib/libs/llvm12/lib/IR/AttributeImpl.h index c69fe3fe08..9bf9574c8a 100644 --- a/contrib/libs/llvm12/lib/IR/AttributeImpl.h +++ b/contrib/libs/llvm12/lib/IR/AttributeImpl.h @@ -121,10 +121,10 @@ protected: public: EnumAttributeImpl(Attribute::AttrKind Kind) - : AttributeImpl(EnumAttrEntry), Kind(Kind) { - assert(Kind != Attribute::AttrKind::None && - "Can't create a None attribute!"); - } + : AttributeImpl(EnumAttrEntry), Kind(Kind) { + assert(Kind != Attribute::AttrKind::None && + "Can't create a None attribute!"); + } Attribute::AttrKind getEnumKind() const { return Kind; } }; @@ -254,8 +254,8 @@ public: std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const; std::string getAsString(bool InAttrGrp) const; Type *getByValType() const; - Type *getStructRetType() const; - Type *getByRefType() const; + Type *getStructRetType() const; + Type *getByRefType() const; Type *getPreallocatedType() const; using iterator = const Attribute *; diff --git a/contrib/libs/llvm12/lib/IR/Attributes.cpp b/contrib/libs/llvm12/lib/IR/Attributes.cpp index c4629decc6..58e23c7885 100644 --- a/contrib/libs/llvm12/lib/IR/Attributes.cpp +++ b/contrib/libs/llvm12/lib/IR/Attributes.cpp @@ -172,14 +172,14 @@ Attribute Attribute::getWithByValType(LLVMContext &Context, Type *Ty) { return get(Context, ByVal, Ty); } -Attribute Attribute::getWithStructRetType(LLVMContext &Context, Type *Ty) { - return get(Context, StructRet, Ty); -} - -Attribute Attribute::getWithByRefType(LLVMContext &Context, Type *Ty) { - return get(Context, ByRef, Ty); -} - +Attribute Attribute::getWithStructRetType(LLVMContext &Context, Type *Ty) { + return get(Context, StructRet, Ty); +} + +Attribute Attribute::getWithByRefType(LLVMContext &Context, Type *Ty) { + return get(Context, ByRef, Ty); +} + Attribute Attribute::getWithPreallocatedType(LLVMContext &Context, Type *Ty) { return get(Context, Preallocated, Ty); } @@ -371,8 +371,8 @@ std::string Attribute::getAsString(bool InAttrGrp) const { return "noalias"; if (hasAttribute(Attribute::NoBuiltin)) return "nobuiltin"; - if (hasAttribute(Attribute::NoCallback)) - return "nocallback"; + if (hasAttribute(Attribute::NoCallback)) + return "nocallback"; if (hasAttribute(Attribute::NoCapture)) return "nocapture"; if (hasAttribute(Attribute::NoDuplicate)) @@ -403,8 +403,8 @@ std::string Attribute::getAsString(bool InAttrGrp) const { return "nocf_check"; if (hasAttribute(Attribute::NoRecurse)) return "norecurse"; - if (hasAttribute(Attribute::NoProfile)) - return "noprofile"; + if (hasAttribute(Attribute::NoProfile)) + return "noprofile"; if (hasAttribute(Attribute::NoUnwind)) return "nounwind"; if (hasAttribute(Attribute::OptForFuzzing)) @@ -451,19 +451,19 @@ std::string Attribute::getAsString(bool InAttrGrp) const { return "zeroext"; if (hasAttribute(Attribute::Cold)) return "cold"; - if (hasAttribute(Attribute::Hot)) - return "hot"; + if (hasAttribute(Attribute::Hot)) + return "hot"; if (hasAttribute(Attribute::ImmArg)) return "immarg"; if (hasAttribute(Attribute::NoUndef)) return "noundef"; - if (hasAttribute(Attribute::MustProgress)) - return "mustprogress"; + if (hasAttribute(Attribute::MustProgress)) + return "mustprogress"; - const bool IsByVal = hasAttribute(Attribute::ByVal); - if (IsByVal || hasAttribute(Attribute::StructRet)) { + const bool IsByVal = hasAttribute(Attribute::ByVal); + if (IsByVal || hasAttribute(Attribute::StructRet)) { std::string Result; - Result += IsByVal ? "byval" : "sret"; + Result += IsByVal ? "byval" : "sret"; if (Type *Ty = getValueAsType()) { raw_string_ostream OS(Result); Result += '('; @@ -474,9 +474,9 @@ std::string Attribute::getAsString(bool InAttrGrp) const { return Result; } - const bool IsByRef = hasAttribute(Attribute::ByRef); - if (IsByRef || hasAttribute(Attribute::Preallocated)) { - std::string Result = IsByRef ? "byref" : "preallocated"; + const bool IsByRef = hasAttribute(Attribute::ByRef); + if (IsByRef || hasAttribute(Attribute::Preallocated)) { + std::string Result = IsByRef ? "byref" : "preallocated"; raw_string_ostream OS(Result); Result += '('; getValueAsType()->print(OS, false, true); @@ -757,18 +757,18 @@ uint64_t AttributeSet::getDereferenceableOrNullBytes() const { return SetNode ? SetNode->getDereferenceableOrNullBytes() : 0; } -Type *AttributeSet::getByRefType() const { - return SetNode ? SetNode->getByRefType() : nullptr; -} - +Type *AttributeSet::getByRefType() const { + return SetNode ? SetNode->getByRefType() : nullptr; +} + Type *AttributeSet::getByValType() const { return SetNode ? SetNode->getByValType() : nullptr; } -Type *AttributeSet::getStructRetType() const { - return SetNode ? SetNode->getStructRetType() : nullptr; -} - +Type *AttributeSet::getStructRetType() const { + return SetNode ? SetNode->getStructRetType() : nullptr; +} + Type *AttributeSet::getPreallocatedType() const { return SetNode ? SetNode->getPreallocatedType() : nullptr; } @@ -865,12 +865,12 @@ AttributeSetNode *AttributeSetNode::get(LLVMContext &C, const AttrBuilder &B) { case Attribute::ByVal: Attr = Attribute::getWithByValType(C, B.getByValType()); break; - case Attribute::StructRet: - Attr = Attribute::getWithStructRetType(C, B.getStructRetType()); - break; - case Attribute::ByRef: - Attr = Attribute::getWithByRefType(C, B.getByRefType()); - break; + case Attribute::StructRet: + Attr = Attribute::getWithStructRetType(C, B.getStructRetType()); + break; + case Attribute::ByRef: + Attr = Attribute::getWithByRefType(C, B.getByRefType()); + break; case Attribute::Preallocated: Attr = Attribute::getWithPreallocatedType(C, B.getPreallocatedType()); break; @@ -954,25 +954,25 @@ MaybeAlign AttributeSetNode::getStackAlignment() const { Type *AttributeSetNode::getByValType() const { if (auto A = findEnumAttribute(Attribute::ByVal)) return A->getValueAsType(); - return nullptr; -} - -Type *AttributeSetNode::getStructRetType() const { - if (auto A = findEnumAttribute(Attribute::StructRet)) - return A->getValueAsType(); - return nullptr; -} - -Type *AttributeSetNode::getByRefType() const { - if (auto A = findEnumAttribute(Attribute::ByRef)) - return A->getValueAsType(); - return nullptr; -} - + return nullptr; +} + +Type *AttributeSetNode::getStructRetType() const { + if (auto A = findEnumAttribute(Attribute::StructRet)) + return A->getValueAsType(); + return nullptr; +} + +Type *AttributeSetNode::getByRefType() const { + if (auto A = findEnumAttribute(Attribute::ByRef)) + return A->getValueAsType(); + return nullptr; +} + Type *AttributeSetNode::getPreallocatedType() const { - if (auto A = findEnumAttribute(Attribute::Preallocated)) - return A->getValueAsType(); - return nullptr; + if (auto A = findEnumAttribute(Attribute::Preallocated)) + return A->getValueAsType(); + return nullptr; } uint64_t AttributeSetNode::getDereferenceableBytes() const { @@ -1010,7 +1010,7 @@ std::string AttributeSetNode::getAsString(bool InAttrGrp) const { /// Map from AttributeList index to the internal array index. Adding one happens /// to work, because -1 wraps around to 0. -static unsigned attrIdxToArrayIdx(unsigned Index) { +static unsigned attrIdxToArrayIdx(unsigned Index) { return Index + 1; } @@ -1023,7 +1023,7 @@ AttributeListImpl::AttributeListImpl(ArrayRef<AttributeSet> Sets) // Initialize AvailableFunctionAttrs and AvailableSomewhereAttrs // summary bitsets. - for (const auto &I : Sets[attrIdxToArrayIdx(AttributeList::FunctionIndex)]) + for (const auto &I : Sets[attrIdxToArrayIdx(AttributeList::FunctionIndex)]) if (!I.isStringAttribute()) AvailableFunctionAttrs.addAttribute(I.getKindAsEnum()); @@ -1111,10 +1111,10 @@ AttributeList::get(LLVMContext &C, return LHS.first < RHS.first; }) && "Misordered Attributes list!"); - assert(llvm::all_of(Attrs, - [](const std::pair<unsigned, Attribute> &Pair) { - return Pair.second.isValid(); - }) && + assert(llvm::all_of(Attrs, + [](const std::pair<unsigned, Attribute> &Pair) { + return Pair.second.isValid(); + }) && "Pointless attribute!"); // Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes @@ -1202,7 +1202,7 @@ AttributeList AttributeList::get(LLVMContext &C, AttributeSet FnAttrs, if (NumSets > 2) { // Drop the empty argument attribute sets at the end. ArgAttrs = ArgAttrs.take_front(NumSets - 2); - llvm::append_range(AttrSets, ArgAttrs); + llvm::append_range(AttrSets, ArgAttrs); } return getImpl(C, AttrSets); @@ -1274,11 +1274,11 @@ AttributeList AttributeList::get(LLVMContext &C, AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const { if (hasAttribute(Index, Kind)) return *this; - AttributeSet Attrs = getAttributes(Index); - // TODO: Insert at correct position and avoid sort. - SmallVector<Attribute, 8> NewAttrs(Attrs.begin(), Attrs.end()); - NewAttrs.push_back(Attribute::get(C, Kind)); - return setAttributes(C, Index, AttributeSet::get(C, NewAttrs)); + AttributeSet Attrs = getAttributes(Index); + // TODO: Insert at correct position and avoid sort. + SmallVector<Attribute, 8> NewAttrs(Attrs.begin(), Attrs.end()); + NewAttrs.push_back(Attribute::get(C, Kind)); + return setAttributes(C, Index, AttributeSet::get(C, NewAttrs)); } AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index, @@ -1296,16 +1296,16 @@ AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index, return addAttributes(C, Index, B); } -AttributeList AttributeList::setAttributes(LLVMContext &C, unsigned Index, - AttributeSet Attrs) const { - Index = attrIdxToArrayIdx(Index); - SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end()); - if (Index >= AttrSets.size()) - AttrSets.resize(Index + 1); - AttrSets[Index] = Attrs; - return AttributeList::getImpl(C, AttrSets); -} - +AttributeList AttributeList::setAttributes(LLVMContext &C, unsigned Index, + AttributeSet Attrs) const { + Index = attrIdxToArrayIdx(Index); + SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end()); + if (Index >= AttrSets.size()) + AttrSets.resize(Index + 1); + AttrSets[Index] = Attrs; + return AttributeList::getImpl(C, AttrSets); +} + AttributeList AttributeList::addAttributes(LLVMContext &C, unsigned Index, const AttrBuilder &B) const { if (!B.hasAttributes()) @@ -1323,9 +1323,9 @@ AttributeList AttributeList::addAttributes(LLVMContext &C, unsigned Index, "Attempt to change alignment!"); #endif - AttrBuilder Merged(getAttributes(Index)); + AttrBuilder Merged(getAttributes(Index)); Merged.merge(B); - return setAttributes(C, Index, AttributeSet::get(C, Merged)); + return setAttributes(C, Index, AttributeSet::get(C, Merged)); } AttributeList AttributeList::addParamAttribute(LLVMContext &C, @@ -1495,14 +1495,14 @@ Type *AttributeList::getParamByValType(unsigned Index) const { return getAttributes(Index+FirstArgIndex).getByValType(); } -Type *AttributeList::getParamStructRetType(unsigned Index) const { - return getAttributes(Index + FirstArgIndex).getStructRetType(); -} - -Type *AttributeList::getParamByRefType(unsigned Index) const { - return getAttributes(Index + FirstArgIndex).getByRefType(); -} - +Type *AttributeList::getParamStructRetType(unsigned Index) const { + return getAttributes(Index + FirstArgIndex).getStructRetType(); +} + +Type *AttributeList::getParamByRefType(unsigned Index) const { + return getAttributes(Index + FirstArgIndex).getByRefType(); +} + Type *AttributeList::getParamPreallocatedType(unsigned Index) const { return getAttributes(Index + FirstArgIndex).getPreallocatedType(); } @@ -1588,8 +1588,8 @@ void AttrBuilder::clear() { DerefBytes = DerefOrNullBytes = 0; AllocSizeArgs = 0; ByValType = nullptr; - StructRetType = nullptr; - ByRefType = nullptr; + StructRetType = nullptr; + ByRefType = nullptr; PreallocatedType = nullptr; } @@ -1608,10 +1608,10 @@ AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) { StackAlignment = Attr.getStackAlignment(); else if (Kind == Attribute::ByVal) ByValType = Attr.getValueAsType(); - else if (Kind == Attribute::StructRet) - StructRetType = Attr.getValueAsType(); - else if (Kind == Attribute::ByRef) - ByRefType = Attr.getValueAsType(); + else if (Kind == Attribute::StructRet) + StructRetType = Attr.getValueAsType(); + else if (Kind == Attribute::ByRef) + ByRefType = Attr.getValueAsType(); else if (Kind == Attribute::Preallocated) PreallocatedType = Attr.getValueAsType(); else if (Kind == Attribute::Dereferenceable) @@ -1638,10 +1638,10 @@ AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) { StackAlignment.reset(); else if (Val == Attribute::ByVal) ByValType = nullptr; - else if (Val == Attribute::StructRet) - StructRetType = nullptr; - else if (Val == Attribute::ByRef) - ByRefType = nullptr; + else if (Val == Attribute::StructRet) + StructRetType = nullptr; + else if (Val == Attribute::ByRef) + ByRefType = nullptr; else if (Val == Attribute::Preallocated) PreallocatedType = nullptr; else if (Val == Attribute::Dereferenceable) @@ -1732,18 +1732,18 @@ AttrBuilder &AttrBuilder::addByValAttr(Type *Ty) { return *this; } -AttrBuilder &AttrBuilder::addStructRetAttr(Type *Ty) { - Attrs[Attribute::StructRet] = true; - StructRetType = Ty; - return *this; -} - -AttrBuilder &AttrBuilder::addByRefAttr(Type *Ty) { - Attrs[Attribute::ByRef] = true; - ByRefType = Ty; - return *this; -} - +AttrBuilder &AttrBuilder::addStructRetAttr(Type *Ty) { + Attrs[Attribute::StructRet] = true; + StructRetType = Ty; + return *this; +} + +AttrBuilder &AttrBuilder::addByRefAttr(Type *Ty) { + Attrs[Attribute::ByRef] = true; + ByRefType = Ty; + return *this; +} + AttrBuilder &AttrBuilder::addPreallocatedAttr(Type *Ty) { Attrs[Attribute::Preallocated] = true; PreallocatedType = Ty; @@ -1770,12 +1770,12 @@ AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) { if (!ByValType) ByValType = B.ByValType; - if (!StructRetType) - StructRetType = B.StructRetType; - - if (!ByRefType) - ByRefType = B.ByRefType; - + if (!StructRetType) + StructRetType = B.StructRetType; + + if (!ByRefType) + ByRefType = B.ByRefType; + if (!PreallocatedType) PreallocatedType = B.PreallocatedType; @@ -1807,12 +1807,12 @@ AttrBuilder &AttrBuilder::remove(const AttrBuilder &B) { if (B.ByValType) ByValType = nullptr; - if (B.StructRetType) - StructRetType = nullptr; - - if (B.ByRefType) - ByRefType = nullptr; - + if (B.StructRetType) + StructRetType = nullptr; + + if (B.ByRefType) + ByRefType = nullptr; + if (B.PreallocatedType) PreallocatedType = nullptr; @@ -1876,7 +1876,7 @@ bool AttrBuilder::operator==(const AttrBuilder &B) const { return Alignment == B.Alignment && StackAlignment == B.StackAlignment && DerefBytes == B.DerefBytes && ByValType == B.ByValType && - StructRetType == B.StructRetType && ByRefType == B.ByRefType && + StructRetType == B.StructRetType && ByRefType == B.ByRefType && PreallocatedType == B.PreallocatedType; } @@ -1899,21 +1899,21 @@ AttrBuilder AttributeFuncs::typeIncompatible(Type *Ty) { .addAttribute(Attribute::NoAlias) .addAttribute(Attribute::NoCapture) .addAttribute(Attribute::NonNull) - .addAlignmentAttr(1) // the int here is ignored + .addAlignmentAttr(1) // the int here is ignored .addDereferenceableAttr(1) // the int here is ignored .addDereferenceableOrNullAttr(1) // the int here is ignored .addAttribute(Attribute::ReadNone) .addAttribute(Attribute::ReadOnly) .addAttribute(Attribute::InAlloca) .addPreallocatedAttr(Ty) - .addByValAttr(Ty) - .addStructRetAttr(Ty) - .addByRefAttr(Ty); - - // Some attributes can apply to all "values" but there are no `void` values. - if (Ty->isVoidTy()) - Incompatible.addAttribute(Attribute::NoUndef); - + .addByValAttr(Ty) + .addStructRetAttr(Ty) + .addByRefAttr(Ty); + + // Some attributes can apply to all "values" but there are no `void` values. + if (Ty->isVoidTy()) + Incompatible.addAttribute(Attribute::NoUndef); + return Incompatible; } @@ -1950,16 +1950,16 @@ static void setOR(Function &Caller, const Function &Callee) { /// If the inlined function had a higher stack protection level than the /// calling function, then bump up the caller's stack protection level. static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) { -#ifndef NDEBUG - if (!Callee.hasFnAttribute(Attribute::AlwaysInline)) { - assert(!(!Callee.hasStackProtectorFnAttr() && - Caller.hasStackProtectorFnAttr()) && - "stack protected caller but callee requested no stack protector"); - assert(!(!Caller.hasStackProtectorFnAttr() && - Callee.hasStackProtectorFnAttr()) && - "stack protected callee but caller requested no stack protector"); - } -#endif +#ifndef NDEBUG + if (!Callee.hasFnAttribute(Attribute::AlwaysInline)) { + assert(!(!Callee.hasStackProtectorFnAttr() && + Caller.hasStackProtectorFnAttr()) && + "stack protected caller but callee requested no stack protector"); + assert(!(!Caller.hasStackProtectorFnAttr() && + Callee.hasStackProtectorFnAttr()) && + "stack protected callee but caller requested no stack protector"); + } +#endif // If upgrading the SSP attribute, clear out the old SSP Attributes first. // Having multiple SSP attributes doesn't actually hurt, but it adds useless // clutter to the IR. @@ -1995,19 +1995,19 @@ static void adjustCallerStackProbes(Function &Caller, const Function &Callee) { /// that is no larger. static void adjustCallerStackProbeSize(Function &Caller, const Function &Callee) { - Attribute CalleeAttr = Callee.getFnAttribute("stack-probe-size"); - if (CalleeAttr.isValid()) { - Attribute CallerAttr = Caller.getFnAttribute("stack-probe-size"); - if (CallerAttr.isValid()) { - uint64_t CallerStackProbeSize, CalleeStackProbeSize; - CallerAttr.getValueAsString().getAsInteger(0, CallerStackProbeSize); - CalleeAttr.getValueAsString().getAsInteger(0, CalleeStackProbeSize); - + Attribute CalleeAttr = Callee.getFnAttribute("stack-probe-size"); + if (CalleeAttr.isValid()) { + Attribute CallerAttr = Caller.getFnAttribute("stack-probe-size"); + if (CallerAttr.isValid()) { + uint64_t CallerStackProbeSize, CalleeStackProbeSize; + CallerAttr.getValueAsString().getAsInteger(0, CallerStackProbeSize); + CalleeAttr.getValueAsString().getAsInteger(0, CalleeStackProbeSize); + if (CallerStackProbeSize > CalleeStackProbeSize) { - Caller.addFnAttr(CalleeAttr); + Caller.addFnAttr(CalleeAttr); } } else { - Caller.addFnAttr(CalleeAttr); + Caller.addFnAttr(CalleeAttr); } } } @@ -2023,15 +2023,15 @@ adjustCallerStackProbeSize(Function &Caller, const Function &Callee) { /// handled as part of inline cost analysis. static void adjustMinLegalVectorWidth(Function &Caller, const Function &Callee) { - Attribute CallerAttr = Caller.getFnAttribute("min-legal-vector-width"); - if (CallerAttr.isValid()) { - Attribute CalleeAttr = Callee.getFnAttribute("min-legal-vector-width"); - if (CalleeAttr.isValid()) { - uint64_t CallerVectorWidth, CalleeVectorWidth; - CallerAttr.getValueAsString().getAsInteger(0, CallerVectorWidth); - CalleeAttr.getValueAsString().getAsInteger(0, CalleeVectorWidth); + Attribute CallerAttr = Caller.getFnAttribute("min-legal-vector-width"); + if (CallerAttr.isValid()) { + Attribute CalleeAttr = Callee.getFnAttribute("min-legal-vector-width"); + if (CalleeAttr.isValid()) { + uint64_t CallerVectorWidth, CalleeVectorWidth; + CallerAttr.getValueAsString().getAsInteger(0, CallerVectorWidth); + CalleeAttr.getValueAsString().getAsInteger(0, CalleeVectorWidth); if (CallerVectorWidth < CalleeVectorWidth) - Caller.addFnAttr(CalleeAttr); + Caller.addFnAttr(CalleeAttr); } else { // If the callee doesn't have the attribute then we don't know anything // and must drop the attribute from the caller. @@ -2098,25 +2098,25 @@ bool AttributeFuncs::areInlineCompatible(const Function &Caller, return hasCompatibleFnAttrs(Caller, Callee); } -bool AttributeFuncs::areOutlineCompatible(const Function &A, - const Function &B) { - return hasCompatibleFnAttrs(A, B); -} - +bool AttributeFuncs::areOutlineCompatible(const Function &A, + const Function &B) { + return hasCompatibleFnAttrs(A, B); +} + void AttributeFuncs::mergeAttributesForInlining(Function &Caller, const Function &Callee) { mergeFnAttrs(Caller, Callee); } - -void AttributeFuncs::mergeAttributesForOutlining(Function &Base, - const Function &ToMerge) { - - // We merge functions so that they meet the most general case. - // For example, if the NoNansFPMathAttr is set in one function, but not in - // the other, in the merged function we can say that the NoNansFPMathAttr - // is not set. - // However if we have the SpeculativeLoadHardeningAttr set true in one - // function, but not the other, we make sure that the function retains - // that aspect in the merged function. - mergeFnAttrs(Base, ToMerge); -} + +void AttributeFuncs::mergeAttributesForOutlining(Function &Base, + const Function &ToMerge) { + + // We merge functions so that they meet the most general case. + // For example, if the NoNansFPMathAttr is set in one function, but not in + // the other, in the merged function we can say that the NoNansFPMathAttr + // is not set. + // However if we have the SpeculativeLoadHardeningAttr set true in one + // function, but not the other, we make sure that the function retains + // that aspect in the merged function. + mergeFnAttrs(Base, ToMerge); +} diff --git a/contrib/libs/llvm12/lib/IR/AutoUpgrade.cpp b/contrib/libs/llvm12/lib/IR/AutoUpgrade.cpp index 7d83cf5dcf..bed972c02b 100644 --- a/contrib/libs/llvm12/lib/IR/AutoUpgrade.cpp +++ b/contrib/libs/llvm12/lib/IR/AutoUpgrade.cpp @@ -23,7 +23,7 @@ #include "llvm/IR/Instruction.h" #include "llvm/IR/InstVisitor.h" #include "llvm/IR/IntrinsicInst.h" -#include "llvm/IR/Intrinsics.h" +#include "llvm/IR/Intrinsics.h" #include "llvm/IR/IntrinsicsAArch64.h" #include "llvm/IR/IntrinsicsARM.h" #include "llvm/IR/IntrinsicsX86.h" @@ -69,19 +69,19 @@ static bool UpgradeX86IntrinsicsWith8BitMask(Function *F, Intrinsic::ID IID, return true; } -// Upgrade the declaration of fp compare intrinsics that change return type -// from scalar to vXi1 mask. -static bool UpgradeX86MaskedFPCompare(Function *F, Intrinsic::ID IID, - Function *&NewFn) { - // Check if the return type is a vector. - if (F->getReturnType()->isVectorTy()) - return false; - - rename(F); - NewFn = Intrinsic::getDeclaration(F->getParent(), IID); - return true; -} - +// Upgrade the declaration of fp compare intrinsics that change return type +// from scalar to vXi1 mask. +static bool UpgradeX86MaskedFPCompare(Function *F, Intrinsic::ID IID, + Function *&NewFn) { + // Check if the return type is a vector. + if (F->getReturnType()->isVectorTy()) + return false; + + rename(F); + NewFn = Intrinsic::getDeclaration(F->getParent(), IID); + return true; +} + static bool ShouldUpgradeX86Intrinsic(Function *F, StringRef Name) { // All of the intrinsics matches below should be marked with which llvm // version started autoupgrading them. At some point in the future we would @@ -255,7 +255,7 @@ static bool ShouldUpgradeX86Intrinsic(Function *F, StringRef Name) { Name.startswith("avx512.mask.cmp.d") || // Added in 5.0 Name.startswith("avx512.mask.cmp.q") || // Added in 5.0 Name.startswith("avx512.mask.cmp.w") || // Added in 5.0 - Name.startswith("avx512.cmp.p") || // Added in 12.0 + Name.startswith("avx512.cmp.p") || // Added in 12.0 Name.startswith("avx512.mask.ucmp.") || // Added in 5.0 Name.startswith("avx512.cvtb2mask.") || // Added in 7.0 Name.startswith("avx512.cvtw2mask.") || // Added in 7.0 @@ -470,24 +470,24 @@ static bool UpgradeX86IntrinsicFunction(Function *F, StringRef Name, if (Name == "avx2.mpsadbw") // Added in 3.6 return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_avx2_mpsadbw, NewFn); - if (Name == "avx512.mask.cmp.pd.128") // Added in 7.0 - return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_pd_128, - NewFn); - if (Name == "avx512.mask.cmp.pd.256") // Added in 7.0 - return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_pd_256, - NewFn); - if (Name == "avx512.mask.cmp.pd.512") // Added in 7.0 - return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_pd_512, - NewFn); - if (Name == "avx512.mask.cmp.ps.128") // Added in 7.0 - return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_ps_128, - NewFn); - if (Name == "avx512.mask.cmp.ps.256") // Added in 7.0 - return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_ps_256, - NewFn); - if (Name == "avx512.mask.cmp.ps.512") // Added in 7.0 - return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_ps_512, - NewFn); + if (Name == "avx512.mask.cmp.pd.128") // Added in 7.0 + return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_pd_128, + NewFn); + if (Name == "avx512.mask.cmp.pd.256") // Added in 7.0 + return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_pd_256, + NewFn); + if (Name == "avx512.mask.cmp.pd.512") // Added in 7.0 + return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_pd_512, + NewFn); + if (Name == "avx512.mask.cmp.ps.128") // Added in 7.0 + return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_ps_128, + NewFn); + if (Name == "avx512.mask.cmp.ps.256") // Added in 7.0 + return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_ps_256, + NewFn); + if (Name == "avx512.mask.cmp.ps.512") // Added in 7.0 + return UpgradeX86MaskedFPCompare(F, Intrinsic::x86_avx512_mask_cmp_ps_512, + NewFn); // frcz.ss/sd may need to have an argument dropped. Added in 3.2 if (Name.startswith("xop.vfrcz.ss") && F->arg_size() == 2) { @@ -633,63 +633,63 @@ static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) { return true; } } - - // Changed in 12.0: bfdot accept v4bf16 and v8bf16 instead of v8i8 and v16i8 - // respectively - if ((Name.startswith("arm.neon.bfdot.") || - Name.startswith("aarch64.neon.bfdot.")) && - Name.endswith("i8")) { - Intrinsic::ID IID = - StringSwitch<Intrinsic::ID>(Name) - .Cases("arm.neon.bfdot.v2f32.v8i8", - "arm.neon.bfdot.v4f32.v16i8", - Intrinsic::arm_neon_bfdot) - .Cases("aarch64.neon.bfdot.v2f32.v8i8", - "aarch64.neon.bfdot.v4f32.v16i8", - Intrinsic::aarch64_neon_bfdot) - .Default(Intrinsic::not_intrinsic); - if (IID == Intrinsic::not_intrinsic) - break; - - size_t OperandWidth = F->getReturnType()->getPrimitiveSizeInBits(); - assert((OperandWidth == 64 || OperandWidth == 128) && - "Unexpected operand width"); - LLVMContext &Ctx = F->getParent()->getContext(); - std::array<Type *, 2> Tys {{ - F->getReturnType(), - FixedVectorType::get(Type::getBFloatTy(Ctx), OperandWidth / 16) - }}; - NewFn = Intrinsic::getDeclaration(F->getParent(), IID, Tys); - return true; - } - - // Changed in 12.0: bfmmla, bfmlalb and bfmlalt are not polymorphic anymore - // and accept v8bf16 instead of v16i8 - if ((Name.startswith("arm.neon.bfm") || - Name.startswith("aarch64.neon.bfm")) && - Name.endswith(".v4f32.v16i8")) { - Intrinsic::ID IID = - StringSwitch<Intrinsic::ID>(Name) - .Case("arm.neon.bfmmla.v4f32.v16i8", - Intrinsic::arm_neon_bfmmla) - .Case("arm.neon.bfmlalb.v4f32.v16i8", - Intrinsic::arm_neon_bfmlalb) - .Case("arm.neon.bfmlalt.v4f32.v16i8", - Intrinsic::arm_neon_bfmlalt) - .Case("aarch64.neon.bfmmla.v4f32.v16i8", - Intrinsic::aarch64_neon_bfmmla) - .Case("aarch64.neon.bfmlalb.v4f32.v16i8", - Intrinsic::aarch64_neon_bfmlalb) - .Case("aarch64.neon.bfmlalt.v4f32.v16i8", - Intrinsic::aarch64_neon_bfmlalt) - .Default(Intrinsic::not_intrinsic); - if (IID == Intrinsic::not_intrinsic) - break; - - std::array<Type *, 0> Tys; - NewFn = Intrinsic::getDeclaration(F->getParent(), IID, Tys); - return true; - } + + // Changed in 12.0: bfdot accept v4bf16 and v8bf16 instead of v8i8 and v16i8 + // respectively + if ((Name.startswith("arm.neon.bfdot.") || + Name.startswith("aarch64.neon.bfdot.")) && + Name.endswith("i8")) { + Intrinsic::ID IID = + StringSwitch<Intrinsic::ID>(Name) + .Cases("arm.neon.bfdot.v2f32.v8i8", + "arm.neon.bfdot.v4f32.v16i8", + Intrinsic::arm_neon_bfdot) + .Cases("aarch64.neon.bfdot.v2f32.v8i8", + "aarch64.neon.bfdot.v4f32.v16i8", + Intrinsic::aarch64_neon_bfdot) + .Default(Intrinsic::not_intrinsic); + if (IID == Intrinsic::not_intrinsic) + break; + + size_t OperandWidth = F->getReturnType()->getPrimitiveSizeInBits(); + assert((OperandWidth == 64 || OperandWidth == 128) && + "Unexpected operand width"); + LLVMContext &Ctx = F->getParent()->getContext(); + std::array<Type *, 2> Tys {{ + F->getReturnType(), + FixedVectorType::get(Type::getBFloatTy(Ctx), OperandWidth / 16) + }}; + NewFn = Intrinsic::getDeclaration(F->getParent(), IID, Tys); + return true; + } + + // Changed in 12.0: bfmmla, bfmlalb and bfmlalt are not polymorphic anymore + // and accept v8bf16 instead of v16i8 + if ((Name.startswith("arm.neon.bfm") || + Name.startswith("aarch64.neon.bfm")) && + Name.endswith(".v4f32.v16i8")) { + Intrinsic::ID IID = + StringSwitch<Intrinsic::ID>(Name) + .Case("arm.neon.bfmmla.v4f32.v16i8", + Intrinsic::arm_neon_bfmmla) + .Case("arm.neon.bfmlalb.v4f32.v16i8", + Intrinsic::arm_neon_bfmlalb) + .Case("arm.neon.bfmlalt.v4f32.v16i8", + Intrinsic::arm_neon_bfmlalt) + .Case("aarch64.neon.bfmmla.v4f32.v16i8", + Intrinsic::aarch64_neon_bfmmla) + .Case("aarch64.neon.bfmlalb.v4f32.v16i8", + Intrinsic::aarch64_neon_bfmlalb) + .Case("aarch64.neon.bfmlalt.v4f32.v16i8", + Intrinsic::aarch64_neon_bfmlalt) + .Default(Intrinsic::not_intrinsic); + if (IID == Intrinsic::not_intrinsic) + break; + + std::array<Type *, 0> Tys; + NewFn = Intrinsic::getDeclaration(F->getParent(), IID, Tys); + return true; + } break; } @@ -718,42 +718,42 @@ static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) { } case 'e': { SmallVector<StringRef, 2> Groups; - static const Regex R("^experimental.vector.reduce.([a-z]+)\\.[a-z][0-9]+"); + static const Regex R("^experimental.vector.reduce.([a-z]+)\\.[a-z][0-9]+"); if (R.match(Name, &Groups)) { - Intrinsic::ID ID; - ID = StringSwitch<Intrinsic::ID>(Groups[1]) - .Case("add", Intrinsic::vector_reduce_add) - .Case("mul", Intrinsic::vector_reduce_mul) - .Case("and", Intrinsic::vector_reduce_and) - .Case("or", Intrinsic::vector_reduce_or) - .Case("xor", Intrinsic::vector_reduce_xor) - .Case("smax", Intrinsic::vector_reduce_smax) - .Case("smin", Intrinsic::vector_reduce_smin) - .Case("umax", Intrinsic::vector_reduce_umax) - .Case("umin", Intrinsic::vector_reduce_umin) - .Case("fmax", Intrinsic::vector_reduce_fmax) - .Case("fmin", Intrinsic::vector_reduce_fmin) - .Default(Intrinsic::not_intrinsic); - if (ID != Intrinsic::not_intrinsic) { - rename(F); - auto Args = F->getFunctionType()->params(); - NewFn = Intrinsic::getDeclaration(F->getParent(), ID, {Args[0]}); - return true; - } - } - static const Regex R2( - "^experimental.vector.reduce.v2.([a-z]+)\\.[fi][0-9]+"); - Groups.clear(); - if (R2.match(Name, &Groups)) { + Intrinsic::ID ID; + ID = StringSwitch<Intrinsic::ID>(Groups[1]) + .Case("add", Intrinsic::vector_reduce_add) + .Case("mul", Intrinsic::vector_reduce_mul) + .Case("and", Intrinsic::vector_reduce_and) + .Case("or", Intrinsic::vector_reduce_or) + .Case("xor", Intrinsic::vector_reduce_xor) + .Case("smax", Intrinsic::vector_reduce_smax) + .Case("smin", Intrinsic::vector_reduce_smin) + .Case("umax", Intrinsic::vector_reduce_umax) + .Case("umin", Intrinsic::vector_reduce_umin) + .Case("fmax", Intrinsic::vector_reduce_fmax) + .Case("fmin", Intrinsic::vector_reduce_fmin) + .Default(Intrinsic::not_intrinsic); + if (ID != Intrinsic::not_intrinsic) { + rename(F); + auto Args = F->getFunctionType()->params(); + NewFn = Intrinsic::getDeclaration(F->getParent(), ID, {Args[0]}); + return true; + } + } + static const Regex R2( + "^experimental.vector.reduce.v2.([a-z]+)\\.[fi][0-9]+"); + Groups.clear(); + if (R2.match(Name, &Groups)) { Intrinsic::ID ID = Intrinsic::not_intrinsic; if (Groups[1] == "fadd") - ID = Intrinsic::vector_reduce_fadd; + ID = Intrinsic::vector_reduce_fadd; if (Groups[1] == "fmul") - ID = Intrinsic::vector_reduce_fmul; + ID = Intrinsic::vector_reduce_fmul; if (ID != Intrinsic::not_intrinsic) { rename(F); auto Args = F->getFunctionType()->params(); - Type *Tys[] = {Args[1]}; + Type *Tys[] = {Args[1]}; NewFn = Intrinsic::getDeclaration(F->getParent(), ID, Tys); return true; } @@ -937,12 +937,12 @@ static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) { Intrinsic::getDeclaration(F->getParent(), Intrinsic::prefetch, Tys); return true; } - } else if (Name.startswith("ptr.annotation.") && F->arg_size() == 4) { - rename(F); - NewFn = Intrinsic::getDeclaration(F->getParent(), - Intrinsic::ptr_annotation, - F->arg_begin()->getType()); - return true; + } else if (Name.startswith("ptr.annotation.") && F->arg_size() == 4) { + rename(F); + NewFn = Intrinsic::getDeclaration(F->getParent(), + Intrinsic::ptr_annotation, + F->arg_begin()->getType()); + return true; } break; @@ -953,16 +953,16 @@ static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) { } break; - case 'v': { - if (Name == "var.annotation" && F->arg_size() == 4) { - rename(F); - NewFn = Intrinsic::getDeclaration(F->getParent(), - Intrinsic::var_annotation); - return true; - } - break; - } - + case 'v': { + if (Name == "var.annotation" && F->arg_size() == 4) { + rename(F); + NewFn = Intrinsic::getDeclaration(F->getParent(), + Intrinsic::var_annotation); + return true; + } + break; + } + case 'x': if (UpgradeX86IntrinsicFunction(F, Name, NewFn)) return true; @@ -1029,7 +1029,7 @@ GlobalVariable *llvm::UpgradeGlobalVariable(GlobalVariable *GV) { // to byte shuffles. static Value *UpgradeX86PSLLDQIntrinsics(IRBuilder<> &Builder, Value *Op, unsigned Shift) { - auto *ResultTy = cast<FixedVectorType>(Op->getType()); + auto *ResultTy = cast<FixedVectorType>(Op->getType()); unsigned NumElts = ResultTy->getNumElements() * 8; // Bitcast from a 64-bit element type to a byte element type. @@ -1063,7 +1063,7 @@ static Value *UpgradeX86PSLLDQIntrinsics(IRBuilder<> &Builder, // to byte shuffles. static Value *UpgradeX86PSRLDQIntrinsics(IRBuilder<> &Builder, Value *Op, unsigned Shift) { - auto *ResultTy = cast<FixedVectorType>(Op->getType()); + auto *ResultTy = cast<FixedVectorType>(Op->getType()); unsigned NumElts = ResultTy->getNumElements() * 8; // Bitcast from a 64-bit element type to a byte element type. @@ -1095,19 +1095,19 @@ static Value *UpgradeX86PSRLDQIntrinsics(IRBuilder<> &Builder, Value *Op, static Value *getX86MaskVec(IRBuilder<> &Builder, Value *Mask, unsigned NumElts) { - assert(isPowerOf2_32(NumElts) && "Expected power-of-2 mask elements"); + assert(isPowerOf2_32(NumElts) && "Expected power-of-2 mask elements"); llvm::VectorType *MaskTy = FixedVectorType::get( Builder.getInt1Ty(), cast<IntegerType>(Mask->getType())->getBitWidth()); Mask = Builder.CreateBitCast(Mask, MaskTy); - // If we have less than 8 elements (1, 2 or 4), then the starting mask was an - // i8 and we need to extract down to the right number of elements. - if (NumElts <= 4) { + // If we have less than 8 elements (1, 2 or 4), then the starting mask was an + // i8 and we need to extract down to the right number of elements. + if (NumElts <= 4) { int Indices[4]; for (unsigned i = 0; i != NumElts; ++i) Indices[i] = i; - Mask = Builder.CreateShuffleVector( - Mask, Mask, makeArrayRef(Indices, NumElts), "extract"); + Mask = Builder.CreateShuffleVector( + Mask, Mask, makeArrayRef(Indices, NumElts), "extract"); } return Mask; @@ -1121,7 +1121,7 @@ static Value *EmitX86Select(IRBuilder<> &Builder, Value *Mask, return Op0; Mask = getX86MaskVec(Builder, Mask, - cast<FixedVectorType>(Op0->getType())->getNumElements()); + cast<FixedVectorType>(Op0->getType())->getNumElements()); return Builder.CreateSelect(Mask, Op0, Op1); } @@ -1148,7 +1148,7 @@ static Value *UpgradeX86ALIGNIntrinsics(IRBuilder<> &Builder, Value *Op0, bool IsVALIGN) { unsigned ShiftVal = cast<llvm::ConstantInt>(Shift)->getZExtValue(); - unsigned NumElts = cast<FixedVectorType>(Op0->getType())->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(Op0->getType())->getNumElements(); assert((IsVALIGN || NumElts % 16 == 0) && "Illegal NumElts for PALIGNR!"); assert((!IsVALIGN || NumElts <= 16) && "NumElts too large for VALIGN!"); assert(isPowerOf2_32(NumElts) && "NumElts not a power of 2!"); @@ -1249,8 +1249,8 @@ static Value *UpgradeX86VPERMT2Intrinsics(IRBuilder<> &Builder, CallInst &CI, return EmitX86Select(Builder, CI.getArgOperand(3), V, PassThru); } -static Value *UpgradeX86BinaryIntrinsics(IRBuilder<> &Builder, CallInst &CI, - Intrinsic::ID IID) { +static Value *UpgradeX86BinaryIntrinsics(IRBuilder<> &Builder, CallInst &CI, + Intrinsic::ID IID) { Type *Ty = CI.getType(); Value *Op0 = CI.getOperand(0); Value *Op1 = CI.getOperand(1); @@ -1275,7 +1275,7 @@ static Value *upgradeX86Rotate(IRBuilder<> &Builder, CallInst &CI, // Funnel shifts amounts are treated as modulo and types are all power-of-2 so // we only care about the lowest log2 bits anyway. if (Amt->getType() != Ty) { - unsigned NumElts = cast<FixedVectorType>(Ty)->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(Ty)->getNumElements(); Amt = Builder.CreateIntCast(Amt, Ty->getScalarType(), false); Amt = Builder.CreateVectorSplat(NumElts, Amt); } @@ -1345,7 +1345,7 @@ static Value *upgradeX86ConcatShift(IRBuilder<> &Builder, CallInst &CI, // Funnel shifts amounts are treated as modulo and types are all power-of-2 so // we only care about the lowest log2 bits anyway. if (Amt->getType() != Ty) { - unsigned NumElts = cast<FixedVectorType>(Ty)->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(Ty)->getNumElements(); Amt = Builder.CreateIntCast(Amt, Ty->getScalarType(), false); Amt = Builder.CreateVectorSplat(NumElts, Amt); } @@ -1382,7 +1382,7 @@ static Value *UpgradeMaskedStore(IRBuilder<> &Builder, return Builder.CreateAlignedStore(Data, Ptr, Alignment); // Convert the mask from an integer type to a vector of i1. - unsigned NumElts = cast<FixedVectorType>(Data->getType())->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(Data->getType())->getNumElements(); Mask = getX86MaskVec(Builder, Mask, NumElts); return Builder.CreateMaskedStore(Data, Ptr, Alignment, Mask); } @@ -1405,19 +1405,19 @@ static Value *UpgradeMaskedLoad(IRBuilder<> &Builder, return Builder.CreateAlignedLoad(ValTy, Ptr, Alignment); // Convert the mask from an integer type to a vector of i1. - unsigned NumElts = - cast<FixedVectorType>(Passthru->getType())->getNumElements(); + unsigned NumElts = + cast<FixedVectorType>(Passthru->getType())->getNumElements(); Mask = getX86MaskVec(Builder, Mask, NumElts); return Builder.CreateMaskedLoad(Ptr, Alignment, Mask, Passthru); } static Value *upgradeAbs(IRBuilder<> &Builder, CallInst &CI) { - Type *Ty = CI.getType(); + Type *Ty = CI.getType(); Value *Op0 = CI.getArgOperand(0); - Function *F = Intrinsic::getDeclaration(CI.getModule(), Intrinsic::abs, Ty); - Value *Res = Builder.CreateCall(F, {Op0, Builder.getInt1(false)}); + Function *F = Intrinsic::getDeclaration(CI.getModule(), Intrinsic::abs, Ty); + Value *Res = Builder.CreateCall(F, {Op0, Builder.getInt1(false)}); if (CI.getNumArgOperands() == 3) - Res = EmitX86Select(Builder, CI.getArgOperand(2), Res, CI.getArgOperand(1)); + Res = EmitX86Select(Builder, CI.getArgOperand(2), Res, CI.getArgOperand(1)); return Res; } @@ -1453,7 +1453,7 @@ static Value *upgradePMULDQ(IRBuilder<> &Builder, CallInst &CI, bool IsSigned) { // Applying mask on vector of i1's and make sure result is at least 8 bits wide. static Value *ApplyX86MaskOn1BitsVec(IRBuilder<> &Builder, Value *Vec, Value *Mask) { - unsigned NumElts = cast<FixedVectorType>(Vec->getType())->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(Vec->getType())->getNumElements(); if (Mask) { const auto *C = dyn_cast<Constant>(Mask); if (!C || !C->isAllOnesValue()) @@ -1476,7 +1476,7 @@ static Value *ApplyX86MaskOn1BitsVec(IRBuilder<> &Builder, Value *Vec, static Value *upgradeMaskedCompare(IRBuilder<> &Builder, CallInst &CI, unsigned CC, bool Signed) { Value *Op0 = CI.getArgOperand(0); - unsigned NumElts = cast<FixedVectorType>(Op0->getType())->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(Op0->getType())->getNumElements(); Value *Cmp; if (CC == 3) { @@ -1531,7 +1531,7 @@ static Value* upgradeMaskedMove(IRBuilder<> &Builder, CallInst &CI) { static Value* UpgradeMaskToInt(IRBuilder<> &Builder, CallInst &CI) { Value* Op = CI.getArgOperand(0); Type* ReturnOp = CI.getType(); - unsigned NumElts = cast<FixedVectorType>(CI.getType())->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(CI.getType())->getNumElements(); Value *Mask = getX86MaskVec(Builder, Op, NumElts); return Builder.CreateSExt(Mask, ReturnOp, "vpmovm2"); } @@ -1979,8 +1979,8 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Rep = Builder.CreateICmp(Pred, Rep, Zero); Rep = ApplyX86MaskOn1BitsVec(Builder, Rep, Mask); } else if (IsX86 && (Name.startswith("avx512.mask.pbroadcast"))){ - unsigned NumElts = cast<FixedVectorType>(CI->getArgOperand(1)->getType()) - ->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(CI->getArgOperand(1)->getType()) + ->getNumElements(); Rep = Builder.CreateVectorSplat(NumElts, CI->getArgOperand(0)); Rep = EmitX86Select(Builder, CI->getArgOperand(2), Rep, CI->getArgOperand(1)); @@ -2108,36 +2108,36 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Rep = Builder.CreateCall(Intrinsic::getDeclaration(F->getParent(), IID), { CI->getOperand(0), CI->getArgOperand(1) }); Rep = ApplyX86MaskOn1BitsVec(Builder, Rep, CI->getArgOperand(2)); - } else if (IsX86 && Name.startswith("avx512.cmp.p")) { - SmallVector<Value *, 4> Args(CI->arg_operands().begin(), - CI->arg_operands().end()); - Type *OpTy = Args[0]->getType(); + } else if (IsX86 && Name.startswith("avx512.cmp.p")) { + SmallVector<Value *, 4> Args(CI->arg_operands().begin(), + CI->arg_operands().end()); + Type *OpTy = Args[0]->getType(); unsigned VecWidth = OpTy->getPrimitiveSizeInBits(); unsigned EltWidth = OpTy->getScalarSizeInBits(); Intrinsic::ID IID; if (VecWidth == 128 && EltWidth == 32) - IID = Intrinsic::x86_avx512_mask_cmp_ps_128; + IID = Intrinsic::x86_avx512_mask_cmp_ps_128; else if (VecWidth == 256 && EltWidth == 32) - IID = Intrinsic::x86_avx512_mask_cmp_ps_256; + IID = Intrinsic::x86_avx512_mask_cmp_ps_256; else if (VecWidth == 512 && EltWidth == 32) - IID = Intrinsic::x86_avx512_mask_cmp_ps_512; + IID = Intrinsic::x86_avx512_mask_cmp_ps_512; else if (VecWidth == 128 && EltWidth == 64) - IID = Intrinsic::x86_avx512_mask_cmp_pd_128; + IID = Intrinsic::x86_avx512_mask_cmp_pd_128; else if (VecWidth == 256 && EltWidth == 64) - IID = Intrinsic::x86_avx512_mask_cmp_pd_256; + IID = Intrinsic::x86_avx512_mask_cmp_pd_256; else if (VecWidth == 512 && EltWidth == 64) - IID = Intrinsic::x86_avx512_mask_cmp_pd_512; + IID = Intrinsic::x86_avx512_mask_cmp_pd_512; else llvm_unreachable("Unexpected intrinsic"); - Value *Mask = Constant::getAllOnesValue(CI->getType()); - if (VecWidth == 512) - std::swap(Mask, Args.back()); - Args.push_back(Mask); + Value *Mask = Constant::getAllOnesValue(CI->getType()); + if (VecWidth == 512) + std::swap(Mask, Args.back()); + Args.push_back(Mask); Rep = Builder.CreateCall(Intrinsic::getDeclaration(F->getParent(), IID), Args); - } else if (IsX86 && Name.startswith("avx512.mask.cmp.")) { + } else if (IsX86 && Name.startswith("avx512.mask.cmp.")) { // Integer compare intrinsics. unsigned Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue(); Rep = upgradeMaskedCompare(Builder, *CI, Imm, true); @@ -2163,25 +2163,25 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Name == "sse41.pmaxsd" || Name.startswith("avx2.pmaxs") || Name.startswith("avx512.mask.pmaxs"))) { - Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::smax); + Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::smax); } else if (IsX86 && (Name == "sse2.pmaxu.b" || Name == "sse41.pmaxuw" || Name == "sse41.pmaxud" || Name.startswith("avx2.pmaxu") || Name.startswith("avx512.mask.pmaxu"))) { - Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::umax); + Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::umax); } else if (IsX86 && (Name == "sse41.pminsb" || Name == "sse2.pmins.w" || Name == "sse41.pminsd" || Name.startswith("avx2.pmins") || Name.startswith("avx512.mask.pmins"))) { - Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::smin); + Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::smin); } else if (IsX86 && (Name == "sse2.pminu.b" || Name == "sse41.pminuw" || Name == "sse41.pminud" || Name.startswith("avx2.pminu") || Name.startswith("avx512.mask.pminu"))) { - Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::umin); + Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::umin); } else if (IsX86 && (Name == "sse2.pmulu.dq" || Name == "avx2.pmulu.dq" || Name == "avx512.pmulu.dq.512" || @@ -2228,9 +2228,9 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Name == "avx.cvt.ps2.pd.256" || Name == "avx512.mask.cvtps2pd.128" || Name == "avx512.mask.cvtps2pd.256")) { - auto *DstTy = cast<FixedVectorType>(CI->getType()); + auto *DstTy = cast<FixedVectorType>(CI->getType()); Rep = CI->getArgOperand(0); - auto *SrcTy = cast<FixedVectorType>(Rep->getType()); + auto *SrcTy = cast<FixedVectorType>(Rep->getType()); unsigned NumDstElts = DstTy->getNumElements(); if (NumDstElts < SrcTy->getNumElements()) { @@ -2260,9 +2260,9 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { CI->getArgOperand(1)); } else if (IsX86 && (Name.startswith("avx512.mask.vcvtph2ps.") || Name.startswith("vcvtph2ps."))) { - auto *DstTy = cast<FixedVectorType>(CI->getType()); + auto *DstTy = cast<FixedVectorType>(CI->getType()); Rep = CI->getArgOperand(0); - auto *SrcTy = cast<FixedVectorType>(Rep->getType()); + auto *SrcTy = cast<FixedVectorType>(Rep->getType()); unsigned NumDstElts = DstTy->getNumElements(); if (NumDstElts != SrcTy->getNumElements()) { assert(NumDstElts == 4 && "Unexpected vector size"); @@ -2283,7 +2283,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { CI->getArgOperand(1),CI->getArgOperand(2), /*Aligned*/true); } else if (IsX86 && Name.startswith("avx512.mask.expand.load.")) { - auto *ResultTy = cast<FixedVectorType>(CI->getType()); + auto *ResultTy = cast<FixedVectorType>(CI->getType()); Type *PtrTy = ResultTy->getElementType(); // Cast the pointer to element type. @@ -2305,9 +2305,9 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Value *Ptr = Builder.CreateBitCast(CI->getOperand(0), llvm::PointerType::getUnqual(PtrTy)); - Value *MaskVec = - getX86MaskVec(Builder, CI->getArgOperand(2), - cast<FixedVectorType>(ResultTy)->getNumElements()); + Value *MaskVec = + getX86MaskVec(Builder, CI->getArgOperand(2), + cast<FixedVectorType>(ResultTy)->getNumElements()); Function *CSt = Intrinsic::getDeclaration(F->getParent(), Intrinsic::masked_compressstore, @@ -2315,7 +2315,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Rep = Builder.CreateCall(CSt, { CI->getArgOperand(1), Ptr, MaskVec }); } else if (IsX86 && (Name.startswith("avx512.mask.compress.") || Name.startswith("avx512.mask.expand."))) { - auto *ResultTy = cast<FixedVectorType>(CI->getType()); + auto *ResultTy = cast<FixedVectorType>(CI->getType()); Value *MaskVec = getX86MaskVec(Builder, CI->getArgOperand(2), ResultTy->getNumElements()); @@ -2395,7 +2395,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { } else if (IsX86 && (Name.startswith("avx.vbroadcast.s") || Name.startswith("avx512.vbroadcast.s"))) { // Replace broadcasts with a series of insertelements. - auto *VecTy = cast<FixedVectorType>(CI->getType()); + auto *VecTy = cast<FixedVectorType>(CI->getType()); Type *EltTy = VecTy->getElementType(); unsigned EltNum = VecTy->getNumElements(); Value *Cast = Builder.CreateBitCast(CI->getArgOperand(0), @@ -2412,7 +2412,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Name.startswith("avx2.pmovzx") || Name.startswith("avx512.mask.pmovsx") || Name.startswith("avx512.mask.pmovzx"))) { - auto *DstTy = cast<FixedVectorType>(CI->getType()); + auto *DstTy = cast<FixedVectorType>(CI->getType()); unsigned NumDstElts = DstTy->getNumElements(); // Extract a subvector of the first NumDstElts lanes and sign/zero extend. @@ -2420,8 +2420,8 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { for (unsigned i = 0; i != NumDstElts; ++i) ShuffleMask[i] = i; - Value *SV = - Builder.CreateShuffleVector(CI->getArgOperand(0), ShuffleMask); + Value *SV = + Builder.CreateShuffleVector(CI->getArgOperand(0), ShuffleMask); bool DoSext = (StringRef::npos != Name.find("pmovsx")); Rep = DoSext ? Builder.CreateSExt(SV, DstTy) @@ -2448,10 +2448,10 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { PointerType::getUnqual(VT)); Value *Load = Builder.CreateAlignedLoad(VT, Op, Align(1)); if (NumSrcElts == 2) - Rep = Builder.CreateShuffleVector(Load, ArrayRef<int>{0, 1, 0, 1}); - else + Rep = Builder.CreateShuffleVector(Load, ArrayRef<int>{0, 1, 0, 1}); + else Rep = Builder.CreateShuffleVector( - Load, ArrayRef<int>{0, 1, 2, 3, 0, 1, 2, 3}); + Load, ArrayRef<int>{0, 1, 2, 3, 0, 1, 2, 3}); } else if (IsX86 && (Name.startswith("avx512.mask.shuf.i") || Name.startswith("avx512.mask.shuf.f"))) { unsigned Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue(); @@ -2477,10 +2477,10 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { }else if (IsX86 && (Name.startswith("avx512.mask.broadcastf") || Name.startswith("avx512.mask.broadcasti"))) { unsigned NumSrcElts = - cast<FixedVectorType>(CI->getArgOperand(0)->getType()) - ->getNumElements(); - unsigned NumDstElts = - cast<FixedVectorType>(CI->getType())->getNumElements(); + cast<FixedVectorType>(CI->getArgOperand(0)->getType()) + ->getNumElements(); + unsigned NumDstElts = + cast<FixedVectorType>(CI->getType())->getNumElements(); SmallVector<int, 8> ShuffleMask(NumDstElts); for (unsigned i = 0; i != NumDstElts; ++i) @@ -2499,31 +2499,31 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Value *Op = CI->getArgOperand(0); ElementCount EC = cast<VectorType>(CI->getType())->getElementCount(); Type *MaskTy = VectorType::get(Type::getInt32Ty(C), EC); - SmallVector<int, 8> M; - ShuffleVectorInst::getShuffleMask(Constant::getNullValue(MaskTy), M); - Rep = Builder.CreateShuffleVector(Op, M); + SmallVector<int, 8> M; + ShuffleVectorInst::getShuffleMask(Constant::getNullValue(MaskTy), M); + Rep = Builder.CreateShuffleVector(Op, M); if (CI->getNumArgOperands() == 3) Rep = EmitX86Select(Builder, CI->getArgOperand(2), Rep, CI->getArgOperand(1)); } else if (IsX86 && (Name.startswith("sse2.padds.") || Name.startswith("avx2.padds.") || - Name.startswith("avx512.padds.") || - Name.startswith("avx512.mask.padds."))) { - Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::sadd_sat); - } else if (IsX86 && (Name.startswith("sse2.psubs.") || + Name.startswith("avx512.padds.") || + Name.startswith("avx512.mask.padds."))) { + Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::sadd_sat); + } else if (IsX86 && (Name.startswith("sse2.psubs.") || Name.startswith("avx2.psubs.") || Name.startswith("avx512.psubs.") || Name.startswith("avx512.mask.psubs."))) { - Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::ssub_sat); + Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::ssub_sat); } else if (IsX86 && (Name.startswith("sse2.paddus.") || Name.startswith("avx2.paddus.") || - Name.startswith("avx512.mask.paddus."))) { - Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::uadd_sat); - } else if (IsX86 && (Name.startswith("sse2.psubus.") || + Name.startswith("avx512.mask.paddus."))) { + Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::uadd_sat); + } else if (IsX86 && (Name.startswith("sse2.psubus.") || Name.startswith("avx2.psubus.") || Name.startswith("avx512.mask.psubus."))) { - Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::usub_sat); + Rep = UpgradeX86BinaryIntrinsics(Builder, *CI, Intrinsic::usub_sat); } else if (IsX86 && Name.startswith("avx512.mask.palignr.")) { Rep = UpgradeX86ALIGNIntrinsics(Builder, CI->getArgOperand(0), CI->getArgOperand(1), @@ -2570,7 +2570,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Value *Op0 = CI->getArgOperand(0); Value *Op1 = CI->getArgOperand(1); unsigned Imm = cast <ConstantInt>(CI->getArgOperand(2))->getZExtValue(); - auto *VecTy = cast<FixedVectorType>(CI->getType()); + auto *VecTy = cast<FixedVectorType>(CI->getType()); unsigned NumElts = VecTy->getNumElements(); SmallVector<int, 16> Idxs(NumElts); @@ -2584,10 +2584,10 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Value *Op0 = CI->getArgOperand(0); Value *Op1 = CI->getArgOperand(1); unsigned Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue(); - unsigned DstNumElts = - cast<FixedVectorType>(CI->getType())->getNumElements(); - unsigned SrcNumElts = - cast<FixedVectorType>(Op1->getType())->getNumElements(); + unsigned DstNumElts = + cast<FixedVectorType>(CI->getType())->getNumElements(); + unsigned SrcNumElts = + cast<FixedVectorType>(Op1->getType())->getNumElements(); unsigned Scale = DstNumElts / SrcNumElts; // Mask off the high bits of the immediate value; hardware ignores those. @@ -2599,7 +2599,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Idxs[i] = i; for (unsigned i = SrcNumElts; i != DstNumElts; ++i) Idxs[i] = SrcNumElts; - Rep = Builder.CreateShuffleVector(Op1, Idxs); + Rep = Builder.CreateShuffleVector(Op1, Idxs); // Insert the second operand into the first operand. @@ -2629,10 +2629,10 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Name.startswith("avx512.mask.vextract"))) { Value *Op0 = CI->getArgOperand(0); unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue(); - unsigned DstNumElts = - cast<FixedVectorType>(CI->getType())->getNumElements(); - unsigned SrcNumElts = - cast<FixedVectorType>(Op0->getType())->getNumElements(); + unsigned DstNumElts = + cast<FixedVectorType>(CI->getType())->getNumElements(); + unsigned SrcNumElts = + cast<FixedVectorType>(Op0->getType())->getNumElements(); unsigned Scale = SrcNumElts / DstNumElts; // Mask off the high bits of the immediate value; hardware ignores those. @@ -2655,7 +2655,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Name.startswith("avx512.mask.perm.di."))) { Value *Op0 = CI->getArgOperand(0); unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue(); - auto *VecTy = cast<FixedVectorType>(CI->getType()); + auto *VecTy = cast<FixedVectorType>(CI->getType()); unsigned NumElts = VecTy->getNumElements(); SmallVector<int, 8> Idxs(NumElts); @@ -2679,7 +2679,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { uint8_t Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue(); - unsigned NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); unsigned HalfSize = NumElts / 2; SmallVector<int, 8> ShuffleMask(NumElts); @@ -2709,7 +2709,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Name.startswith("avx512.mask.pshuf.d."))) { Value *Op0 = CI->getArgOperand(0); unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue(); - auto *VecTy = cast<FixedVectorType>(CI->getType()); + auto *VecTy = cast<FixedVectorType>(CI->getType()); unsigned NumElts = VecTy->getNumElements(); // Calculate the size of each index in the immediate. unsigned IdxSize = 64 / VecTy->getScalarSizeInBits(); @@ -2731,7 +2731,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Name.startswith("avx512.mask.pshufl.w."))) { Value *Op0 = CI->getArgOperand(0); unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue(); - unsigned NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); SmallVector<int, 16> Idxs(NumElts); for (unsigned l = 0; l != NumElts; l += 8) { @@ -2750,7 +2750,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Name.startswith("avx512.mask.pshufh.w."))) { Value *Op0 = CI->getArgOperand(0); unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue(); - unsigned NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); SmallVector<int, 16> Idxs(NumElts); for (unsigned l = 0; l != NumElts; l += 8) { @@ -2769,7 +2769,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Value *Op0 = CI->getArgOperand(0); Value *Op1 = CI->getArgOperand(1); unsigned Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue(); - unsigned NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); unsigned NumLaneElts = 128/CI->getType()->getScalarSizeInBits(); unsigned HalfLaneElts = NumLaneElts / 2; @@ -2794,7 +2794,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Name.startswith("avx512.mask.movshdup") || Name.startswith("avx512.mask.movsldup"))) { Value *Op0 = CI->getArgOperand(0); - unsigned NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); unsigned NumLaneElts = 128/CI->getType()->getScalarSizeInBits(); unsigned Offset = 0; @@ -2816,7 +2816,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Name.startswith("avx512.mask.unpckl."))) { Value *Op0 = CI->getArgOperand(0); Value *Op1 = CI->getArgOperand(1); - int NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); + int NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); int NumLaneElts = 128/CI->getType()->getScalarSizeInBits(); SmallVector<int, 64> Idxs(NumElts); @@ -2832,7 +2832,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Name.startswith("avx512.mask.unpckh."))) { Value *Op0 = CI->getArgOperand(0); Value *Op1 = CI->getArgOperand(1); - int NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); + int NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); int NumLaneElts = 128/CI->getType()->getScalarSizeInBits(); SmallVector<int, 64> Idxs(NumElts); @@ -3400,7 +3400,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { Rep = Builder.CreateCall(Intrinsic::getDeclaration(F->getParent(), IID), Ops); } else { - int NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); + int NumElts = cast<FixedVectorType>(CI->getType())->getNumElements(); Value *Ops[] = { CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2) }; @@ -3677,30 +3677,30 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { break; } - case Intrinsic::arm_neon_bfdot: - case Intrinsic::arm_neon_bfmmla: - case Intrinsic::arm_neon_bfmlalb: - case Intrinsic::arm_neon_bfmlalt: - case Intrinsic::aarch64_neon_bfdot: - case Intrinsic::aarch64_neon_bfmmla: - case Intrinsic::aarch64_neon_bfmlalb: - case Intrinsic::aarch64_neon_bfmlalt: { - SmallVector<Value *, 3> Args; - assert(CI->getNumArgOperands() == 3 && - "Mismatch between function args and call args"); - size_t OperandWidth = - CI->getArgOperand(1)->getType()->getPrimitiveSizeInBits(); - assert((OperandWidth == 64 || OperandWidth == 128) && - "Unexpected operand width"); - Type *NewTy = FixedVectorType::get(Type::getBFloatTy(C), OperandWidth / 16); - auto Iter = CI->arg_operands().begin(); - Args.push_back(*Iter++); - Args.push_back(Builder.CreateBitCast(*Iter++, NewTy)); - Args.push_back(Builder.CreateBitCast(*Iter++, NewTy)); - NewCall = Builder.CreateCall(NewFn, Args); - break; - } - + case Intrinsic::arm_neon_bfdot: + case Intrinsic::arm_neon_bfmmla: + case Intrinsic::arm_neon_bfmlalb: + case Intrinsic::arm_neon_bfmlalt: + case Intrinsic::aarch64_neon_bfdot: + case Intrinsic::aarch64_neon_bfmmla: + case Intrinsic::aarch64_neon_bfmlalb: + case Intrinsic::aarch64_neon_bfmlalt: { + SmallVector<Value *, 3> Args; + assert(CI->getNumArgOperands() == 3 && + "Mismatch between function args and call args"); + size_t OperandWidth = + CI->getArgOperand(1)->getType()->getPrimitiveSizeInBits(); + assert((OperandWidth == 64 || OperandWidth == 128) && + "Unexpected operand width"); + Type *NewTy = FixedVectorType::get(Type::getBFloatTy(C), OperandWidth / 16); + auto Iter = CI->arg_operands().begin(); + Args.push_back(*Iter++); + Args.push_back(Builder.CreateBitCast(*Iter++, NewTy)); + Args.push_back(Builder.CreateBitCast(*Iter++, NewTy)); + NewCall = Builder.CreateCall(NewFn, Args); + break; + } + case Intrinsic::bitreverse: NewCall = Builder.CreateCall(NewFn, {CI->getArgOperand(0)}); break; @@ -3746,32 +3746,32 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { CI->eraseFromParent(); return; - case Intrinsic::ptr_annotation: - // Upgrade from versions that lacked the annotation attribute argument. - assert(CI->getNumArgOperands() == 4 && - "Before LLVM 12.0 this intrinsic took four arguments"); - // Create a new call with an added null annotation attribute argument. - NewCall = Builder.CreateCall( - NewFn, - {CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), - CI->getArgOperand(3), Constant::getNullValue(Builder.getInt8PtrTy())}); - NewCall->takeName(CI); - CI->replaceAllUsesWith(NewCall); - CI->eraseFromParent(); - return; - - case Intrinsic::var_annotation: - // Upgrade from versions that lacked the annotation attribute argument. - assert(CI->getNumArgOperands() == 4 && - "Before LLVM 12.0 this intrinsic took four arguments"); - // Create a new call with an added null annotation attribute argument. - NewCall = Builder.CreateCall( - NewFn, - {CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), - CI->getArgOperand(3), Constant::getNullValue(Builder.getInt8PtrTy())}); - CI->eraseFromParent(); - return; - + case Intrinsic::ptr_annotation: + // Upgrade from versions that lacked the annotation attribute argument. + assert(CI->getNumArgOperands() == 4 && + "Before LLVM 12.0 this intrinsic took four arguments"); + // Create a new call with an added null annotation attribute argument. + NewCall = Builder.CreateCall( + NewFn, + {CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), + CI->getArgOperand(3), Constant::getNullValue(Builder.getInt8PtrTy())}); + NewCall->takeName(CI); + CI->replaceAllUsesWith(NewCall); + CI->eraseFromParent(); + return; + + case Intrinsic::var_annotation: + // Upgrade from versions that lacked the annotation attribute argument. + assert(CI->getNumArgOperands() == 4 && + "Before LLVM 12.0 this intrinsic took four arguments"); + // Create a new call with an added null annotation attribute argument. + NewCall = Builder.CreateCall( + NewFn, + {CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), + CI->getArgOperand(3), Constant::getNullValue(Builder.getInt8PtrTy())}); + CI->eraseFromParent(); + return; + case Intrinsic::x86_xop_vfrcz_ss: case Intrinsic::x86_xop_vfrcz_sd: NewCall = Builder.CreateCall(NewFn, {CI->getArgOperand(1)}); @@ -3829,7 +3829,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { // Replace the original call result with the first result of the new call. Value *TSC = Builder.CreateExtractValue(NewCall, 0); - NewCall->takeName(CI); + NewCall->takeName(CI); CI->replaceAllUsesWith(TSC); CI->eraseFromParent(); return; @@ -3852,27 +3852,27 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { break; } - case Intrinsic::x86_avx512_mask_cmp_pd_128: - case Intrinsic::x86_avx512_mask_cmp_pd_256: - case Intrinsic::x86_avx512_mask_cmp_pd_512: - case Intrinsic::x86_avx512_mask_cmp_ps_128: - case Intrinsic::x86_avx512_mask_cmp_ps_256: - case Intrinsic::x86_avx512_mask_cmp_ps_512: { - SmallVector<Value *, 4> Args(CI->arg_operands().begin(), - CI->arg_operands().end()); - unsigned NumElts = - cast<FixedVectorType>(Args[0]->getType())->getNumElements(); - Args[3] = getX86MaskVec(Builder, Args[3], NumElts); - - NewCall = Builder.CreateCall(NewFn, Args); - Value *Res = ApplyX86MaskOn1BitsVec(Builder, NewCall, nullptr); - - NewCall->takeName(CI); - CI->replaceAllUsesWith(Res); - CI->eraseFromParent(); - return; - } - + case Intrinsic::x86_avx512_mask_cmp_pd_128: + case Intrinsic::x86_avx512_mask_cmp_pd_256: + case Intrinsic::x86_avx512_mask_cmp_pd_512: + case Intrinsic::x86_avx512_mask_cmp_ps_128: + case Intrinsic::x86_avx512_mask_cmp_ps_256: + case Intrinsic::x86_avx512_mask_cmp_ps_512: { + SmallVector<Value *, 4> Args(CI->arg_operands().begin(), + CI->arg_operands().end()); + unsigned NumElts = + cast<FixedVectorType>(Args[0]->getType())->getNumElements(); + Args[3] = getX86MaskVec(Builder, Args[3], NumElts); + + NewCall = Builder.CreateCall(NewFn, Args); + Value *Res = ApplyX86MaskOn1BitsVec(Builder, NewCall, nullptr); + + NewCall->takeName(CI); + CI->replaceAllUsesWith(Res); + CI->eraseFromParent(); + return; + } + case Intrinsic::thread_pointer: { NewCall = Builder.CreateCall(NewFn, {}); break; @@ -3921,7 +3921,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) { } assert(NewCall && "Should have either set this variable or returned through " "the default case"); - NewCall->takeName(CI); + NewCall->takeName(CI); CI->replaceAllUsesWith(NewCall); CI->eraseFromParent(); } @@ -3935,8 +3935,8 @@ void llvm::UpgradeCallsToIntrinsic(Function *F) { if (UpgradeIntrinsicFunction(F, NewFn)) { // Replace all users of the old function with the new function or new // instructions. This is not a range loop because the call is deleted. - for (User *U : make_early_inc_range(F->users())) - if (CallInst *CI = dyn_cast<CallInst>(U)) + for (User *U : make_early_inc_range(F->users())) + if (CallInst *CI = dyn_cast<CallInst>(U)) UpgradeIntrinsicCall(CI, NewFn); // Remove old function, no longer used, from the module. @@ -4072,8 +4072,8 @@ void llvm::UpgradeARCRuntime(Module &M) { Function *NewFn = llvm::Intrinsic::getDeclaration(&M, IntrinsicFunc); - for (User *U : make_early_inc_range(Fn->users())) { - CallInst *CI = dyn_cast<CallInst>(U); + for (User *U : make_early_inc_range(Fn->users())) { + CallInst *CI = dyn_cast<CallInst>(U); if (!CI || CI->getCalledFunction() != Fn) continue; @@ -4114,7 +4114,7 @@ void llvm::UpgradeARCRuntime(Module &M) { // Create a call instruction that calls the new function. CallInst *NewCall = Builder.CreateCall(NewFuncTy, NewFn, Args); NewCall->setTailCallKind(cast<CallInst>(CI)->getTailCallKind()); - NewCall->takeName(CI); + NewCall->takeName(CI); // Bitcast the return value back to the type of the old call. Value *NewRetVal = Builder.CreateBitCast(NewCall, CI->getType()); @@ -4353,13 +4353,13 @@ void llvm::UpgradeFunctionAttributes(Function &F) { StrictFPUpgradeVisitor SFPV; SFPV.visit(F); } - - if (F.getCallingConv() == CallingConv::X86_INTR && - !F.arg_empty() && !F.hasParamAttribute(0, Attribute::ByVal)) { - Type *ByValTy = cast<PointerType>(F.getArg(0)->getType())->getElementType(); - Attribute NewAttr = Attribute::getWithByValType(F.getContext(), ByValTy); - F.addParamAttr(0, NewAttr); - } + + if (F.getCallingConv() == CallingConv::X86_INTR && + !F.arg_empty() && !F.hasParamAttribute(0, Attribute::ByVal)) { + Type *ByValTy = cast<PointerType>(F.getArg(0)->getType())->getElementType(); + Attribute NewAttr = Attribute::getWithByValType(F.getContext(), ByValTy); + F.addParamAttr(0, NewAttr); + } } static bool isOldLoopArgument(Metadata *MD) { @@ -4425,17 +4425,17 @@ MDNode *llvm::upgradeInstructionLoopAttachment(MDNode &N) { } std::string llvm::UpgradeDataLayoutString(StringRef DL, StringRef TT) { - Triple T(TT); - // For AMDGPU we uprgrade older DataLayouts to include the default globals - // address space of 1. - if (T.isAMDGPU() && !DL.contains("-G") && !DL.startswith("G")) { - return DL.empty() ? std::string("G1") : (DL + "-G1").str(); - } - + Triple T(TT); + // For AMDGPU we uprgrade older DataLayouts to include the default globals + // address space of 1. + if (T.isAMDGPU() && !DL.contains("-G") && !DL.startswith("G")) { + return DL.empty() ? std::string("G1") : (DL + "-G1").str(); + } + std::string AddrSpaces = "-p270:32:32-p271:32:32-p272:64:64"; // If X86, and the datalayout matches the expected format, add pointer size // address spaces to the datalayout. - if (!T.isX86() || DL.contains(AddrSpaces)) + if (!T.isX86() || DL.contains(AddrSpaces)) return std::string(DL); SmallVector<StringRef, 4> Groups; @@ -4443,7 +4443,7 @@ std::string llvm::UpgradeDataLayoutString(StringRef DL, StringRef TT) { if (!R.match(DL, &Groups)) return std::string(DL); - return (Groups[1] + AddrSpaces + Groups[3]).str(); + return (Groups[1] + AddrSpaces + Groups[3]).str(); } void llvm::UpgradeAttributes(AttrBuilder &B) { diff --git a/contrib/libs/llvm12/lib/IR/BasicBlock.cpp b/contrib/libs/llvm12/lib/IR/BasicBlock.cpp index 00ef10dd53..217386b4bb 100644 --- a/contrib/libs/llvm12/lib/IR/BasicBlock.cpp +++ b/contrib/libs/llvm12/lib/IR/BasicBlock.cpp @@ -97,20 +97,20 @@ void BasicBlock::setParent(Function *parent) { iterator_range<filter_iterator<BasicBlock::const_iterator, std::function<bool(const Instruction &)>>> -BasicBlock::instructionsWithoutDebug(bool SkipPseudoOp) const { - std::function<bool(const Instruction &)> Fn = [=](const Instruction &I) { - return !isa<DbgInfoIntrinsic>(I) && - !(SkipPseudoOp && isa<PseudoProbeInst>(I)); +BasicBlock::instructionsWithoutDebug(bool SkipPseudoOp) const { + std::function<bool(const Instruction &)> Fn = [=](const Instruction &I) { + return !isa<DbgInfoIntrinsic>(I) && + !(SkipPseudoOp && isa<PseudoProbeInst>(I)); }; return make_filter_range(*this, Fn); } -iterator_range< - filter_iterator<BasicBlock::iterator, std::function<bool(Instruction &)>>> -BasicBlock::instructionsWithoutDebug(bool SkipPseudoOp) { - std::function<bool(Instruction &)> Fn = [=](Instruction &I) { - return !isa<DbgInfoIntrinsic>(I) && - !(SkipPseudoOp && isa<PseudoProbeInst>(I)); +iterator_range< + filter_iterator<BasicBlock::iterator, std::function<bool(Instruction &)>>> +BasicBlock::instructionsWithoutDebug(bool SkipPseudoOp) { + std::function<bool(Instruction &)> Fn = [=](Instruction &I) { + return !isa<DbgInfoIntrinsic>(I) && + !(SkipPseudoOp && isa<PseudoProbeInst>(I)); }; return make_filter_range(*this, Fn); } @@ -216,21 +216,21 @@ const Instruction* BasicBlock::getFirstNonPHI() const { return nullptr; } -const Instruction *BasicBlock::getFirstNonPHIOrDbg(bool SkipPseudoOp) const { - for (const Instruction &I : *this) { - if (isa<PHINode>(I) || isa<DbgInfoIntrinsic>(I)) - continue; - - if (SkipPseudoOp && isa<PseudoProbeInst>(I)) - continue; - - return &I; - } +const Instruction *BasicBlock::getFirstNonPHIOrDbg(bool SkipPseudoOp) const { + for (const Instruction &I : *this) { + if (isa<PHINode>(I) || isa<DbgInfoIntrinsic>(I)) + continue; + + if (SkipPseudoOp && isa<PseudoProbeInst>(I)) + continue; + + return &I; + } return nullptr; } -const Instruction * -BasicBlock::getFirstNonPHIOrDbgOrLifetime(bool SkipPseudoOp) const { +const Instruction * +BasicBlock::getFirstNonPHIOrDbgOrLifetime(bool SkipPseudoOp) const { for (const Instruction &I : *this) { if (isa<PHINode>(I) || isa<DbgInfoIntrinsic>(I)) continue; @@ -238,9 +238,9 @@ BasicBlock::getFirstNonPHIOrDbgOrLifetime(bool SkipPseudoOp) const { if (I.isLifetimeStartOrEnd()) continue; - if (SkipPseudoOp && isa<PseudoProbeInst>(I)) - continue; - + if (SkipPseudoOp && isa<PseudoProbeInst>(I)) + continue; + return &I; } return nullptr; @@ -321,28 +321,28 @@ iterator_range<BasicBlock::phi_iterator> BasicBlock::phis() { void BasicBlock::removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs) { // Use hasNUsesOrMore to bound the cost of this assertion for complex CFGs. - assert((hasNUsesOrMore(16) || llvm::is_contained(predecessors(this), Pred)) && + assert((hasNUsesOrMore(16) || llvm::is_contained(predecessors(this), Pred)) && "Pred is not a predecessor!"); // Return early if there are no PHI nodes to update. - if (empty() || !isa<PHINode>(begin())) + if (empty() || !isa<PHINode>(begin())) return; - + unsigned NumPreds = cast<PHINode>(front()).getNumIncomingValues(); - for (PHINode &Phi : make_early_inc_range(phis())) { - Phi.removeIncomingValue(Pred, !KeepOneInputPHIs); - if (KeepOneInputPHIs) - continue; - - // If we have a single predecessor, removeIncomingValue may have erased the - // PHI node itself. - if (NumPreds == 1) - continue; - - // Try to replace the PHI node with a constant value. - if (Value *PhiConstant = Phi.hasConstantValue()) { - Phi.replaceAllUsesWith(PhiConstant); - Phi.eraseFromParent(); + for (PHINode &Phi : make_early_inc_range(phis())) { + Phi.removeIncomingValue(Pred, !KeepOneInputPHIs); + if (KeepOneInputPHIs) + continue; + + // If we have a single predecessor, removeIncomingValue may have erased the + // PHI node itself. + if (NumPreds == 1) + continue; + + // Try to replace the PHI node with a constant value. + if (Value *PhiConstant = Phi.hasConstantValue()) { + Phi.replaceAllUsesWith(PhiConstant); + Phi.eraseFromParent(); } } } @@ -372,11 +372,11 @@ bool BasicBlock::isLegalToHoistInto() const { return !Term->isExceptionalTerminator(); } -BasicBlock *BasicBlock::splitBasicBlock(iterator I, const Twine &BBName, - bool Before) { - if (Before) - return splitBasicBlockBefore(I, BBName); - +BasicBlock *BasicBlock::splitBasicBlock(iterator I, const Twine &BBName, + bool Before) { + if (Before) + return splitBasicBlockBefore(I, BBName); + assert(getTerminator() && "Can't use splitBasicBlock on degenerate BB!"); assert(I != InstList.end() && "Trying to get me to create degenerate basic block!"); @@ -403,40 +403,40 @@ BasicBlock *BasicBlock::splitBasicBlock(iterator I, const Twine &BBName, return New; } -BasicBlock *BasicBlock::splitBasicBlockBefore(iterator I, const Twine &BBName) { - assert(getTerminator() && - "Can't use splitBasicBlockBefore on degenerate BB!"); - assert(I != InstList.end() && - "Trying to get me to create degenerate basic block!"); - - assert((!isa<PHINode>(*I) || getSinglePredecessor()) && - "cannot split on multi incoming phis"); - - BasicBlock *New = BasicBlock::Create(getContext(), BBName, getParent(), this); - // Save DebugLoc of split point before invalidating iterator. - DebugLoc Loc = I->getDebugLoc(); - // Move all of the specified instructions from the original basic block into - // the new basic block. - New->getInstList().splice(New->end(), this->getInstList(), begin(), I); - - // Loop through all of the predecessors of the 'this' block (which will be the - // predecessors of the New block), replace the specified successor 'this' - // block to point at the New block and update any PHI nodes in 'this' block. - // If there were PHI nodes in 'this' block, the PHI nodes are updated - // to reflect that the incoming branches will be from the New block and not - // from predecessors of the 'this' block. - for (BasicBlock *Pred : predecessors(this)) { - Instruction *TI = Pred->getTerminator(); - TI->replaceSuccessorWith(this, New); - this->replacePhiUsesWith(Pred, New); - } - // Add a branch instruction from "New" to "this" Block. - BranchInst *BI = BranchInst::Create(this, New); - BI->setDebugLoc(Loc); - - return New; -} - +BasicBlock *BasicBlock::splitBasicBlockBefore(iterator I, const Twine &BBName) { + assert(getTerminator() && + "Can't use splitBasicBlockBefore on degenerate BB!"); + assert(I != InstList.end() && + "Trying to get me to create degenerate basic block!"); + + assert((!isa<PHINode>(*I) || getSinglePredecessor()) && + "cannot split on multi incoming phis"); + + BasicBlock *New = BasicBlock::Create(getContext(), BBName, getParent(), this); + // Save DebugLoc of split point before invalidating iterator. + DebugLoc Loc = I->getDebugLoc(); + // Move all of the specified instructions from the original basic block into + // the new basic block. + New->getInstList().splice(New->end(), this->getInstList(), begin(), I); + + // Loop through all of the predecessors of the 'this' block (which will be the + // predecessors of the New block), replace the specified successor 'this' + // block to point at the New block and update any PHI nodes in 'this' block. + // If there were PHI nodes in 'this' block, the PHI nodes are updated + // to reflect that the incoming branches will be from the New block and not + // from predecessors of the 'this' block. + for (BasicBlock *Pred : predecessors(this)) { + Instruction *TI = Pred->getTerminator(); + TI->replaceSuccessorWith(this, New); + this->replacePhiUsesWith(Pred, New); + } + // Add a branch instruction from "New" to "this" Block. + BranchInst *BI = BranchInst::Create(this, New); + BI->setDebugLoc(Loc); + + return New; +} + void BasicBlock::replacePhiUsesWith(BasicBlock *Old, BasicBlock *New) { // N.B. This might not be a complete BasicBlock, so don't assume // that it ends with a non-phi instruction. diff --git a/contrib/libs/llvm12/lib/IR/ConstantFold.cpp b/contrib/libs/llvm12/lib/IR/ConstantFold.cpp index 95dd55237e..56a95ad639 100644 --- a/contrib/libs/llvm12/lib/IR/ConstantFold.cpp +++ b/contrib/libs/llvm12/lib/IR/ConstantFold.cpp @@ -522,9 +522,9 @@ static Constant *getFoldedOffsetOf(Type *Ty, Constant *FieldNo, Type *DestTy, Constant *llvm::ConstantFoldCastInstruction(unsigned opc, Constant *V, Type *DestTy) { - if (isa<PoisonValue>(V)) - return PoisonValue::get(DestTy); - + if (isa<PoisonValue>(V)) + return PoisonValue::get(DestTy); + if (isa<UndefValue>(V)) { // zext(undef) = 0, because the top bits will be zero. // sext(undef) = 0, because the top bits will all be the same. @@ -535,7 +535,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, Constant *V, return UndefValue::get(DestTy); } - if (V->isNullValue() && !DestTy->isX86_MMXTy() && !DestTy->isX86_AMXTy() && + if (V->isNullValue() && !DestTy->isX86_MMXTy() && !DestTy->isX86_AMXTy() && opc != Instruction::AddrSpaceCast) return Constant::getNullValue(DestTy); @@ -762,9 +762,9 @@ Constant *llvm::ConstantFoldSelectInstruction(Constant *Cond, Constant *V2Element = ConstantExpr::getExtractElement(V2, ConstantInt::get(Ty, i)); auto *Cond = cast<Constant>(CondV->getOperand(i)); - if (isa<PoisonValue>(Cond)) { - V = PoisonValue::get(V1Element->getType()); - } else if (V1Element == V2Element) { + if (isa<PoisonValue>(Cond)) { + V = PoisonValue::get(V1Element->getType()); + } else if (V1Element == V2Element) { V = V1Element; } else if (isa<UndefValue>(Cond)) { V = isa<UndefValue>(V1Element) ? V1Element : V2Element; @@ -780,45 +780,45 @@ Constant *llvm::ConstantFoldSelectInstruction(Constant *Cond, return ConstantVector::get(Result); } - if (isa<PoisonValue>(Cond)) - return PoisonValue::get(V1->getType()); - + if (isa<PoisonValue>(Cond)) + return PoisonValue::get(V1->getType()); + if (isa<UndefValue>(Cond)) { if (isa<UndefValue>(V1)) return V1; return V2; } - + if (V1 == V2) return V1; - if (isa<PoisonValue>(V1)) - return V2; - if (isa<PoisonValue>(V2)) - return V1; - - // If the true or false value is undef, we can fold to the other value as - // long as the other value isn't poison. - auto NotPoison = [](Constant *C) { - if (isa<PoisonValue>(C)) - return false; - - // TODO: We can analyze ConstExpr by opcode to determine if there is any - // possibility of poison. - if (isa<ConstantExpr>(C)) - return false; - - if (isa<ConstantInt>(C) || isa<GlobalVariable>(C) || isa<ConstantFP>(C) || - isa<ConstantPointerNull>(C) || isa<Function>(C)) - return true; - - if (C->getType()->isVectorTy()) - return !C->containsPoisonElement() && !C->containsConstantExpression(); - - // TODO: Recursively analyze aggregates or other constants. - return false; - }; - if (isa<UndefValue>(V1) && NotPoison(V2)) return V2; - if (isa<UndefValue>(V2) && NotPoison(V1)) return V1; - + if (isa<PoisonValue>(V1)) + return V2; + if (isa<PoisonValue>(V2)) + return V1; + + // If the true or false value is undef, we can fold to the other value as + // long as the other value isn't poison. + auto NotPoison = [](Constant *C) { + if (isa<PoisonValue>(C)) + return false; + + // TODO: We can analyze ConstExpr by opcode to determine if there is any + // possibility of poison. + if (isa<ConstantExpr>(C)) + return false; + + if (isa<ConstantInt>(C) || isa<GlobalVariable>(C) || isa<ConstantFP>(C) || + isa<ConstantPointerNull>(C) || isa<Function>(C)) + return true; + + if (C->getType()->isVectorTy()) + return !C->containsPoisonElement() && !C->containsConstantExpression(); + + // TODO: Recursively analyze aggregates or other constants. + return false; + }; + if (isa<UndefValue>(V1) && NotPoison(V2)) return V2; + if (isa<UndefValue>(V2) && NotPoison(V1)) return V1; + if (ConstantExpr *TrueVal = dyn_cast<ConstantExpr>(V1)) { if (TrueVal->getOpcode() == Instruction::Select) if (TrueVal->getOperand(0) == Cond) @@ -837,13 +837,13 @@ Constant *llvm::ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx) { auto *ValVTy = cast<VectorType>(Val->getType()); - // extractelt poison, C -> poison - // extractelt C, undef -> poison - if (isa<PoisonValue>(Val) || isa<UndefValue>(Idx)) - return PoisonValue::get(ValVTy->getElementType()); - + // extractelt poison, C -> poison + // extractelt C, undef -> poison + if (isa<PoisonValue>(Val) || isa<UndefValue>(Idx)) + return PoisonValue::get(ValVTy->getElementType()); + // extractelt undef, C -> undef - if (isa<UndefValue>(Val)) + if (isa<UndefValue>(Val)) return UndefValue::get(ValVTy->getElementType()); auto *CIdx = dyn_cast<ConstantInt>(Idx); @@ -851,9 +851,9 @@ Constant *llvm::ConstantFoldExtractElementInstruction(Constant *Val, return nullptr; if (auto *ValFVTy = dyn_cast<FixedVectorType>(Val->getType())) { - // ee({w,x,y,z}, wrong_value) -> poison + // ee({w,x,y,z}, wrong_value) -> poison if (CIdx->uge(ValFVTy->getNumElements())) - return PoisonValue::get(ValFVTy->getElementType()); + return PoisonValue::get(ValFVTy->getElementType()); } // ee (gep (ptr, idx0, ...), idx) -> gep (ee (ptr, idx), ee (idx0, idx), ...) @@ -873,15 +873,15 @@ Constant *llvm::ConstantFoldExtractElementInstruction(Constant *Val, } return CE->getWithOperands(Ops, ValVTy->getElementType(), false, Ops[0]->getType()->getPointerElementType()); - } else if (CE->getOpcode() == Instruction::InsertElement) { - if (const auto *IEIdx = dyn_cast<ConstantInt>(CE->getOperand(2))) { - if (APSInt::isSameValue(APSInt(IEIdx->getValue()), - APSInt(CIdx->getValue()))) { - return CE->getOperand(1); - } else { - return ConstantExpr::getExtractElement(CE->getOperand(0), CIdx); - } - } + } else if (CE->getOpcode() == Instruction::InsertElement) { + if (const auto *IEIdx = dyn_cast<ConstantInt>(CE->getOperand(2))) { + if (APSInt::isSameValue(APSInt(IEIdx->getValue()), + APSInt(CIdx->getValue()))) { + return CE->getOperand(1); + } else { + return ConstantExpr::getExtractElement(CE->getOperand(0), CIdx); + } + } } } @@ -902,7 +902,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt, Constant *Idx) { if (isa<UndefValue>(Idx)) - return PoisonValue::get(Val->getType()); + return PoisonValue::get(Val->getType()); ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx); if (!CIdx) return nullptr; @@ -939,8 +939,8 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, ArrayRef<int> Mask) { auto *V1VTy = cast<VectorType>(V1->getType()); unsigned MaskNumElts = Mask.size(); - auto MaskEltCount = - ElementCount::get(MaskNumElts, isa<ScalableVectorType>(V1VTy)); + auto MaskEltCount = + ElementCount::get(MaskNumElts, isa<ScalableVectorType>(V1VTy)); Type *EltTy = V1VTy->getElementType(); // Undefined shuffle mask -> undefined value. @@ -951,7 +951,7 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, // If the mask is all zeros this is a splat, no need to go through all // elements. if (all_of(Mask, [](int Elt) { return Elt == 0; }) && - !MaskEltCount.isScalable()) { + !MaskEltCount.isScalable()) { Type *Ty = IntegerType::get(V1->getContext(), 32); Constant *Elt = ConstantExpr::getExtractElement(V1, ConstantInt::get(Ty, 0)); @@ -962,7 +962,7 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, if (isa<ScalableVectorType>(V1VTy)) return nullptr; - unsigned SrcNumElts = V1VTy->getElementCount().getKnownMinValue(); + unsigned SrcNumElts = V1VTy->getElementCount().getKnownMinValue(); // Loop over the shuffle mask, evaluating each element. SmallVector<Constant*, 32> Result; @@ -1104,17 +1104,17 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, Constant *C1, return C1; } - // Binary operations propagate poison. - // FIXME: Currently, or/and i1 poison aren't folded into poison because - // it causes miscompilation when combined with another optimization in - // InstCombine (select i1 -> and/or). The select fold is wrong, but - // fixing it requires an effort, so temporarily disable this until it is - // fixed. - bool PoisonFold = !C1->getType()->isIntegerTy(1) || - (Opcode != Instruction::Or && Opcode != Instruction::And); - if (PoisonFold && (isa<PoisonValue>(C1) || isa<PoisonValue>(C2))) - return PoisonValue::get(C1->getType()); - + // Binary operations propagate poison. + // FIXME: Currently, or/and i1 poison aren't folded into poison because + // it causes miscompilation when combined with another optimization in + // InstCombine (select i1 -> and/or). The select fold is wrong, but + // fixing it requires an effort, so temporarily disable this until it is + // fixed. + bool PoisonFold = !C1->getType()->isIntegerTy(1) || + (Opcode != Instruction::Or && Opcode != Instruction::And); + if (PoisonFold && (isa<PoisonValue>(C1) || isa<PoisonValue>(C2))) + return PoisonValue::get(C1->getType()); + // Handle scalar UndefValue and scalable vector UndefValue. Fixed-length // vectors are always evaluated per element. bool IsScalableVector = isa<ScalableVectorType>(C1->getType()); @@ -1439,7 +1439,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, Constant *C1, return ConstantFP::get(C1->getContext(), C3V); } } - } else if (auto *VTy = dyn_cast<VectorType>(C1->getType())) { + } else if (auto *VTy = dyn_cast<VectorType>(C1->getType())) { // Fast path for splatted constants. if (Constant *C2Splat = C2->getSplatValue()) { if (Instruction::isIntDivRem(Opcode) && C2Splat->isNullValue()) @@ -1451,23 +1451,23 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, Constant *C1, } } - if (auto *FVTy = dyn_cast<FixedVectorType>(VTy)) { - // Fold each element and create a vector constant from those constants. - SmallVector<Constant*, 16> Result; - Type *Ty = IntegerType::get(FVTy->getContext(), 32); - for (unsigned i = 0, e = FVTy->getNumElements(); i != e; ++i) { - Constant *ExtractIdx = ConstantInt::get(Ty, i); - Constant *LHS = ConstantExpr::getExtractElement(C1, ExtractIdx); - Constant *RHS = ConstantExpr::getExtractElement(C2, ExtractIdx); - - // If any element of a divisor vector is zero, the whole op is undef. - if (Instruction::isIntDivRem(Opcode) && RHS->isNullValue()) - return UndefValue::get(VTy); - - Result.push_back(ConstantExpr::get(Opcode, LHS, RHS)); - } - - return ConstantVector::get(Result); + if (auto *FVTy = dyn_cast<FixedVectorType>(VTy)) { + // Fold each element and create a vector constant from those constants. + SmallVector<Constant*, 16> Result; + Type *Ty = IntegerType::get(FVTy->getContext(), 32); + for (unsigned i = 0, e = FVTy->getNumElements(); i != e; ++i) { + Constant *ExtractIdx = ConstantInt::get(Ty, i); + Constant *LHS = ConstantExpr::getExtractElement(C1, ExtractIdx); + Constant *RHS = ConstantExpr::getExtractElement(C2, ExtractIdx); + + // If any element of a divisor vector is zero, the whole op is undef. + if (Instruction::isIntDivRem(Opcode) && RHS->isNullValue()) + return UndefValue::get(VTy); + + Result.push_back(ConstantExpr::get(Opcode, LHS, RHS)); + } + + return ConstantVector::get(Result); } } @@ -1782,13 +1782,13 @@ static ICmpInst::Predicate evaluateICmpRelation(Constant *V1, Constant *V2, case Instruction::FPToSI: break; // We can't evaluate floating point casts or truncations. - case Instruction::BitCast: - // If this is a global value cast, check to see if the RHS is also a - // GlobalValue. - if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0)) - if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2)) - return areGlobalsPotentiallyEqual(GV, GV2); - LLVM_FALLTHROUGH; + case Instruction::BitCast: + // If this is a global value cast, check to see if the RHS is also a + // GlobalValue. + if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0)) + if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2)) + return areGlobalsPotentiallyEqual(GV, GV2); + LLVM_FALLTHROUGH; case Instruction::UIToFP: case Instruction::SIToFP: case Instruction::ZExt: @@ -1953,9 +1953,9 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, return Constant::getAllOnesValue(ResultTy); // Handle some degenerate cases first - if (isa<PoisonValue>(C1) || isa<PoisonValue>(C2)) - return PoisonValue::get(ResultTy); - + if (isa<PoisonValue>(C1) || isa<PoisonValue>(C2)) + return PoisonValue::get(ResultTy); + if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) { CmpInst::Predicate Predicate = CmpInst::Predicate(pred); bool isIntegerPredicate = ICmpInst::isIntPredicate(Predicate); @@ -2083,22 +2083,22 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, C1VTy->getElementCount(), ConstantExpr::getCompare(pred, C1Splat, C2Splat)); - // Do not iterate on scalable vector. The number of elements is unknown at - // compile-time. - if (isa<ScalableVectorType>(C1VTy)) - return nullptr; - + // Do not iterate on scalable vector. The number of elements is unknown at + // compile-time. + if (isa<ScalableVectorType>(C1VTy)) + return nullptr; + // If we can constant fold the comparison of each element, constant fold // the whole vector comparison. SmallVector<Constant*, 4> ResElts; Type *Ty = IntegerType::get(C1->getContext(), 32); // Compare the elements, producing an i1 result or constant expr. - for (unsigned I = 0, E = C1VTy->getElementCount().getKnownMinValue(); - I != E; ++I) { + for (unsigned I = 0, E = C1VTy->getElementCount().getKnownMinValue(); + I != E; ++I) { Constant *C1E = - ConstantExpr::getExtractElement(C1, ConstantInt::get(Ty, I)); + ConstantExpr::getExtractElement(C1, ConstantInt::get(Ty, I)); Constant *C2E = - ConstantExpr::getExtractElement(C2, ConstantInt::get(Ty, I)); + ConstantExpr::getExtractElement(C2, ConstantInt::get(Ty, I)); ResElts.push_back(ConstantExpr::getCompare(pred, C1E, C2E)); } @@ -2341,9 +2341,9 @@ Constant *llvm::ConstantFoldGetElementPtr(Type *PointeeTy, Constant *C, Type *GEPTy = GetElementPtrInst::getGEPReturnType( PointeeTy, C, makeArrayRef((Value *const *)Idxs.data(), Idxs.size())); - if (isa<PoisonValue>(C)) - return PoisonValue::get(GEPTy); - + if (isa<PoisonValue>(C)) + return PoisonValue::get(GEPTy); + if (isa<UndefValue>(C)) return UndefValue::get(GEPTy); diff --git a/contrib/libs/llvm12/lib/IR/ConstantRange.cpp b/contrib/libs/llvm12/lib/IR/ConstantRange.cpp index 4b0ad1bd25..0277ab5b5c 100644 --- a/contrib/libs/llvm12/lib/IR/ConstantRange.cpp +++ b/contrib/libs/llvm12/lib/IR/ConstantRange.cpp @@ -26,7 +26,7 @@ #include "llvm/IR/Constants.h" #include "llvm/IR/InstrTypes.h" #include "llvm/IR/Instruction.h" -#include "llvm/IR/Intrinsics.h" +#include "llvm/IR/Intrinsics.h" #include "llvm/IR/Metadata.h" #include "llvm/IR/Operator.h" #include "llvm/Support/Compiler.h" @@ -413,21 +413,21 @@ bool ConstantRange::contains(const ConstantRange &Other) const { return Other.getUpper().ule(Upper) && Lower.ule(Other.getLower()); } -unsigned ConstantRange::getActiveBits() const { - if (isEmptySet()) - return 0; - - return getUnsignedMax().getActiveBits(); -} - -unsigned ConstantRange::getMinSignedBits() const { - if (isEmptySet()) - return 0; - - return std::max(getSignedMin().getMinSignedBits(), - getSignedMax().getMinSignedBits()); -} - +unsigned ConstantRange::getActiveBits() const { + if (isEmptySet()) + return 0; + + return getUnsignedMax().getActiveBits(); +} + +unsigned ConstantRange::getMinSignedBits() const { + if (isEmptySet()) + return 0; + + return std::max(getSignedMin().getMinSignedBits(), + getSignedMax().getMinSignedBits()); +} + ConstantRange ConstantRange::subtract(const APInt &Val) const { assert(Val.getBitWidth() == getBitWidth() && "Wrong bit width"); // If the set is empty or full, don't modify the endpoints. @@ -851,54 +851,54 @@ ConstantRange ConstantRange::overflowingBinaryOp(Instruction::BinaryOps BinOp, } } -bool ConstantRange::isIntrinsicSupported(Intrinsic::ID IntrinsicID) { - switch (IntrinsicID) { - case Intrinsic::uadd_sat: - case Intrinsic::usub_sat: - case Intrinsic::sadd_sat: - case Intrinsic::ssub_sat: - case Intrinsic::umin: - case Intrinsic::umax: - case Intrinsic::smin: - case Intrinsic::smax: - case Intrinsic::abs: - return true; - default: - return false; - } -} - -ConstantRange ConstantRange::intrinsic(Intrinsic::ID IntrinsicID, - ArrayRef<ConstantRange> Ops) { - switch (IntrinsicID) { - case Intrinsic::uadd_sat: - return Ops[0].uadd_sat(Ops[1]); - case Intrinsic::usub_sat: - return Ops[0].usub_sat(Ops[1]); - case Intrinsic::sadd_sat: - return Ops[0].sadd_sat(Ops[1]); - case Intrinsic::ssub_sat: - return Ops[0].ssub_sat(Ops[1]); - case Intrinsic::umin: - return Ops[0].umin(Ops[1]); - case Intrinsic::umax: - return Ops[0].umax(Ops[1]); - case Intrinsic::smin: - return Ops[0].smin(Ops[1]); - case Intrinsic::smax: - return Ops[0].smax(Ops[1]); - case Intrinsic::abs: { - const APInt *IntMinIsPoison = Ops[1].getSingleElement(); - assert(IntMinIsPoison && "Must be known (immarg)"); - assert(IntMinIsPoison->getBitWidth() == 1 && "Must be boolean"); - return Ops[0].abs(IntMinIsPoison->getBoolValue()); - } - default: - assert(!isIntrinsicSupported(IntrinsicID) && "Shouldn't be supported"); - llvm_unreachable("Unsupported intrinsic"); - } -} - +bool ConstantRange::isIntrinsicSupported(Intrinsic::ID IntrinsicID) { + switch (IntrinsicID) { + case Intrinsic::uadd_sat: + case Intrinsic::usub_sat: + case Intrinsic::sadd_sat: + case Intrinsic::ssub_sat: + case Intrinsic::umin: + case Intrinsic::umax: + case Intrinsic::smin: + case Intrinsic::smax: + case Intrinsic::abs: + return true; + default: + return false; + } +} + +ConstantRange ConstantRange::intrinsic(Intrinsic::ID IntrinsicID, + ArrayRef<ConstantRange> Ops) { + switch (IntrinsicID) { + case Intrinsic::uadd_sat: + return Ops[0].uadd_sat(Ops[1]); + case Intrinsic::usub_sat: + return Ops[0].usub_sat(Ops[1]); + case Intrinsic::sadd_sat: + return Ops[0].sadd_sat(Ops[1]); + case Intrinsic::ssub_sat: + return Ops[0].ssub_sat(Ops[1]); + case Intrinsic::umin: + return Ops[0].umin(Ops[1]); + case Intrinsic::umax: + return Ops[0].umax(Ops[1]); + case Intrinsic::smin: + return Ops[0].smin(Ops[1]); + case Intrinsic::smax: + return Ops[0].smax(Ops[1]); + case Intrinsic::abs: { + const APInt *IntMinIsPoison = Ops[1].getSingleElement(); + assert(IntMinIsPoison && "Must be known (immarg)"); + assert(IntMinIsPoison->getBitWidth() == 1 && "Must be boolean"); + return Ops[0].abs(IntMinIsPoison->getBoolValue()); + } + default: + assert(!isIntrinsicSupported(IntrinsicID) && "Shouldn't be supported"); + llvm_unreachable("Unsupported intrinsic"); + } +} + ConstantRange ConstantRange::add(const ConstantRange &Other) const { if (isEmptySet() || Other.isEmptySet()) @@ -1255,16 +1255,16 @@ ConstantRange ConstantRange::srem(const ConstantRange &RHS) const { return ConstantRange(std::move(Lower), std::move(Upper)); } -ConstantRange ConstantRange::binaryNot() const { - if (isEmptySet()) - return getEmpty(); - - if (isWrappedSet()) - return getFull(); - - return ConstantRange(APInt::getAllOnesValue(getBitWidth())).sub(*this); -} - +ConstantRange ConstantRange::binaryNot() const { + if (isEmptySet()) + return getEmpty(); + + if (isWrappedSet()) + return getFull(); + + return ConstantRange(APInt::getAllOnesValue(getBitWidth())).sub(*this); +} + ConstantRange ConstantRange::binaryAnd(const ConstantRange &Other) const { if (isEmptySet() || Other.isEmptySet()) @@ -1303,12 +1303,12 @@ ConstantRange ConstantRange::binaryXor(const ConstantRange &Other) const { if (isSingleElement() && Other.isSingleElement()) return {*getSingleElement() ^ *Other.getSingleElement()}; - // Special-case binary complement, since we can give a precise answer. - if (Other.isSingleElement() && Other.getSingleElement()->isAllOnesValue()) - return binaryNot(); - if (isSingleElement() && getSingleElement()->isAllOnesValue()) - return Other.binaryNot(); - + // Special-case binary complement, since we can give a precise answer. + if (Other.isSingleElement() && Other.getSingleElement()->isAllOnesValue()) + return binaryNot(); + if (isSingleElement() && getSingleElement()->isAllOnesValue()) + return Other.binaryNot(); + // TODO: replace this with something less conservative return getFull(); } @@ -1498,7 +1498,7 @@ ConstantRange ConstantRange::inverse() const { return ConstantRange(Upper, Lower); } -ConstantRange ConstantRange::abs(bool IntMinIsPoison) const { +ConstantRange ConstantRange::abs(bool IntMinIsPoison) const { if (isEmptySet()) return getEmpty(); @@ -1510,23 +1510,23 @@ ConstantRange ConstantRange::abs(bool IntMinIsPoison) const { else Lo = APIntOps::umin(Lower, -Upper + 1); - // If SignedMin is not poison, then it is included in the result range. - if (IntMinIsPoison) - return ConstantRange(Lo, APInt::getSignedMinValue(getBitWidth())); - else - return ConstantRange(Lo, APInt::getSignedMinValue(getBitWidth()) + 1); + // If SignedMin is not poison, then it is included in the result range. + if (IntMinIsPoison) + return ConstantRange(Lo, APInt::getSignedMinValue(getBitWidth())); + else + return ConstantRange(Lo, APInt::getSignedMinValue(getBitWidth()) + 1); } APInt SMin = getSignedMin(), SMax = getSignedMax(); - // Skip SignedMin if it is poison. - if (IntMinIsPoison && SMin.isMinSignedValue()) { - // The range may become empty if it *only* contains SignedMin. - if (SMax.isMinSignedValue()) - return getEmpty(); - ++SMin; - } - + // Skip SignedMin if it is poison. + if (IntMinIsPoison && SMin.isMinSignedValue()) { + // The range may become empty if it *only* contains SignedMin. + if (SMax.isMinSignedValue()) + return getEmpty(); + ++SMin; + } + // All non-negative. if (SMin.isNonNegative()) return *this; diff --git a/contrib/libs/llvm12/lib/IR/Constants.cpp b/contrib/libs/llvm12/lib/IR/Constants.cpp index 9f05917cf7..2c93f98c5d 100644 --- a/contrib/libs/llvm12/lib/IR/Constants.cpp +++ b/contrib/libs/llvm12/lib/IR/Constants.cpp @@ -161,7 +161,7 @@ bool Constant::isNotOneValue() const { // Check that vectors don't contain 1 if (auto *VTy = dyn_cast<VectorType>(this->getType())) { - unsigned NumElts = cast<FixedVectorType>(VTy)->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(VTy)->getNumElements(); for (unsigned i = 0; i != NumElts; ++i) { Constant *Elt = this->getAggregateElement(i); if (!Elt || !Elt->isNotOneValue()) @@ -211,7 +211,7 @@ bool Constant::isNotMinSignedValue() const { // Check that vectors don't contain INT_MIN if (auto *VTy = dyn_cast<VectorType>(this->getType())) { - unsigned NumElts = cast<FixedVectorType>(VTy)->getNumElements(); + unsigned NumElts = cast<FixedVectorType>(VTy)->getNumElements(); for (unsigned i = 0; i != NumElts; ++i) { Constant *Elt = this->getAggregateElement(i); if (!Elt || !Elt->isNotMinSignedValue()) @@ -227,7 +227,7 @@ bool Constant::isNotMinSignedValue() const { bool Constant::isFiniteNonZeroFP() const { if (auto *CFP = dyn_cast<ConstantFP>(this)) return CFP->getValueAPF().isFiniteNonZero(); - auto *VTy = dyn_cast<FixedVectorType>(getType()); + auto *VTy = dyn_cast<FixedVectorType>(getType()); if (!VTy) return false; for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { @@ -304,38 +304,38 @@ bool Constant::isElementWiseEqual(Value *Y) const { return isa<UndefValue>(CmpEq) || match(CmpEq, m_One()); } -static bool -containsUndefinedElement(const Constant *C, - function_ref<bool(const Constant *)> HasFn) { - if (auto *VTy = dyn_cast<VectorType>(C->getType())) { - if (HasFn(C)) - return true; - if (isa<ConstantAggregateZero>(C)) - return false; - if (isa<ScalableVectorType>(C->getType())) - return false; - - for (unsigned i = 0, e = cast<FixedVectorType>(VTy)->getNumElements(); - i != e; ++i) - if (HasFn(C->getAggregateElement(i))) +static bool +containsUndefinedElement(const Constant *C, + function_ref<bool(const Constant *)> HasFn) { + if (auto *VTy = dyn_cast<VectorType>(C->getType())) { + if (HasFn(C)) + return true; + if (isa<ConstantAggregateZero>(C)) + return false; + if (isa<ScalableVectorType>(C->getType())) + return false; + + for (unsigned i = 0, e = cast<FixedVectorType>(VTy)->getNumElements(); + i != e; ++i) + if (HasFn(C->getAggregateElement(i))) return true; } return false; } -bool Constant::containsUndefOrPoisonElement() const { - return containsUndefinedElement( - this, [&](const auto *C) { return isa<UndefValue>(C); }); -} - -bool Constant::containsPoisonElement() const { - return containsUndefinedElement( - this, [&](const auto *C) { return isa<PoisonValue>(C); }); -} - +bool Constant::containsUndefOrPoisonElement() const { + return containsUndefinedElement( + this, [&](const auto *C) { return isa<UndefValue>(C); }); +} + +bool Constant::containsPoisonElement() const { + return containsUndefinedElement( + this, [&](const auto *C) { return isa<PoisonValue>(C); }); +} + bool Constant::containsConstantExpression() const { - if (auto *VTy = dyn_cast<FixedVectorType>(getType())) { + if (auto *VTy = dyn_cast<FixedVectorType>(getType())) { for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) if (isa<ConstantExpr>(getAggregateElement(i))) return true; @@ -419,23 +419,23 @@ Constant *Constant::getAllOnesValue(Type *Ty) { } Constant *Constant::getAggregateElement(unsigned Elt) const { - if (const auto *CC = dyn_cast<ConstantAggregate>(this)) + if (const auto *CC = dyn_cast<ConstantAggregate>(this)) return Elt < CC->getNumOperands() ? CC->getOperand(Elt) : nullptr; - // FIXME: getNumElements() will fail for non-fixed vector types. - if (isa<ScalableVectorType>(getType())) - return nullptr; - - if (const auto *CAZ = dyn_cast<ConstantAggregateZero>(this)) + // FIXME: getNumElements() will fail for non-fixed vector types. + if (isa<ScalableVectorType>(getType())) + return nullptr; + + if (const auto *CAZ = dyn_cast<ConstantAggregateZero>(this)) return Elt < CAZ->getNumElements() ? CAZ->getElementValue(Elt) : nullptr; - if (const auto *PV = dyn_cast<PoisonValue>(this)) - return Elt < PV->getNumElements() ? PV->getElementValue(Elt) : nullptr; - - if (const auto *UV = dyn_cast<UndefValue>(this)) + if (const auto *PV = dyn_cast<PoisonValue>(this)) + return Elt < PV->getNumElements() ? PV->getElementValue(Elt) : nullptr; + + if (const auto *UV = dyn_cast<UndefValue>(this)) return Elt < UV->getNumElements() ? UV->getElementValue(Elt) : nullptr; - if (const auto *CDS = dyn_cast<ConstantDataSequential>(this)) + if (const auto *CDS = dyn_cast<ConstantDataSequential>(this)) return Elt < CDS->getNumElements() ? CDS->getElementAsConstant(Elt) : nullptr; return nullptr; @@ -527,15 +527,15 @@ void llvm::deleteConstant(Constant *C) { case Constant::BlockAddressVal: delete static_cast<BlockAddress *>(C); break; - case Constant::DSOLocalEquivalentVal: - delete static_cast<DSOLocalEquivalent *>(C); - break; + case Constant::DSOLocalEquivalentVal: + delete static_cast<DSOLocalEquivalent *>(C); + break; case Constant::UndefValueVal: delete static_cast<UndefValue *>(C); break; - case Constant::PoisonValueVal: - delete static_cast<PoisonValue *>(C); - break; + case Constant::PoisonValueVal: + delete static_cast<PoisonValue *>(C); + break; case Constant::ConstantExprVal: if (isa<UnaryConstantExpr>(C)) delete static_cast<UnaryConstantExpr *>(C); @@ -678,17 +678,17 @@ bool Constant::needsRelocation() const { return false; // Relative pointers do not need to be dynamically relocated. - if (auto *RHSGV = - dyn_cast<GlobalValue>(RHSOp0->stripInBoundsConstantOffsets())) { - auto *LHS = LHSOp0->stripInBoundsConstantOffsets(); - if (auto *LHSGV = dyn_cast<GlobalValue>(LHS)) { + if (auto *RHSGV = + dyn_cast<GlobalValue>(RHSOp0->stripInBoundsConstantOffsets())) { + auto *LHS = LHSOp0->stripInBoundsConstantOffsets(); + if (auto *LHSGV = dyn_cast<GlobalValue>(LHS)) { if (LHSGV->isDSOLocal() && RHSGV->isDSOLocal()) return false; - } else if (isa<DSOLocalEquivalent>(LHS)) { - if (RHSGV->isDSOLocal()) - return false; - } - } + } else if (isa<DSOLocalEquivalent>(LHS)) { + if (RHSGV->isDSOLocal()) + return false; + } + } } } } @@ -768,53 +768,53 @@ Constant *Constant::replaceUndefsWith(Constant *C, Constant *Replacement) { return ConstantVector::get(NewC); } -Constant *Constant::mergeUndefsWith(Constant *C, Constant *Other) { - assert(C && Other && "Expected non-nullptr constant arguments"); - if (match(C, m_Undef())) - return C; - - Type *Ty = C->getType(); - if (match(Other, m_Undef())) - return UndefValue::get(Ty); - - auto *VTy = dyn_cast<FixedVectorType>(Ty); - if (!VTy) - return C; - - Type *EltTy = VTy->getElementType(); - unsigned NumElts = VTy->getNumElements(); - assert(isa<FixedVectorType>(Other->getType()) && - cast<FixedVectorType>(Other->getType())->getNumElements() == NumElts && - "Type mismatch"); - - bool FoundExtraUndef = false; - SmallVector<Constant *, 32> NewC(NumElts); - for (unsigned I = 0; I != NumElts; ++I) { - NewC[I] = C->getAggregateElement(I); - Constant *OtherEltC = Other->getAggregateElement(I); - assert(NewC[I] && OtherEltC && "Unknown vector element"); - if (!match(NewC[I], m_Undef()) && match(OtherEltC, m_Undef())) { - NewC[I] = UndefValue::get(EltTy); - FoundExtraUndef = true; - } - } - if (FoundExtraUndef) - return ConstantVector::get(NewC); - return C; -} - -bool Constant::isManifestConstant() const { - if (isa<ConstantData>(this)) - return true; - if (isa<ConstantAggregate>(this) || isa<ConstantExpr>(this)) { - for (const Value *Op : operand_values()) - if (!cast<Constant>(Op)->isManifestConstant()) - return false; - return true; - } - return false; -} - +Constant *Constant::mergeUndefsWith(Constant *C, Constant *Other) { + assert(C && Other && "Expected non-nullptr constant arguments"); + if (match(C, m_Undef())) + return C; + + Type *Ty = C->getType(); + if (match(Other, m_Undef())) + return UndefValue::get(Ty); + + auto *VTy = dyn_cast<FixedVectorType>(Ty); + if (!VTy) + return C; + + Type *EltTy = VTy->getElementType(); + unsigned NumElts = VTy->getNumElements(); + assert(isa<FixedVectorType>(Other->getType()) && + cast<FixedVectorType>(Other->getType())->getNumElements() == NumElts && + "Type mismatch"); + + bool FoundExtraUndef = false; + SmallVector<Constant *, 32> NewC(NumElts); + for (unsigned I = 0; I != NumElts; ++I) { + NewC[I] = C->getAggregateElement(I); + Constant *OtherEltC = Other->getAggregateElement(I); + assert(NewC[I] && OtherEltC && "Unknown vector element"); + if (!match(NewC[I], m_Undef()) && match(OtherEltC, m_Undef())) { + NewC[I] = UndefValue::get(EltTy); + FoundExtraUndef = true; + } + } + if (FoundExtraUndef) + return ConstantVector::get(NewC); + return C; +} + +bool Constant::isManifestConstant() const { + if (isa<ConstantData>(this)) + return true; + if (isa<ConstantAggregate>(this) || isa<ConstantExpr>(this)) { + for (const Value *Op : operand_values()) + if (!cast<Constant>(Op)->isManifestConstant()) + return false; + return true; + } + return false; +} + //===----------------------------------------------------------------------===// // ConstantInt //===----------------------------------------------------------------------===// @@ -838,10 +838,10 @@ ConstantInt *ConstantInt::getFalse(LLVMContext &Context) { return pImpl->TheFalseVal; } -ConstantInt *ConstantInt::getBool(LLVMContext &Context, bool V) { - return V ? getTrue(Context) : getFalse(Context); -} - +ConstantInt *ConstantInt::getBool(LLVMContext &Context, bool V) { + return V ? getTrue(Context) : getFalse(Context); +} + Constant *ConstantInt::getTrue(Type *Ty) { assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1."); ConstantInt *TrueC = ConstantInt::getTrue(Ty->getContext()); @@ -858,10 +858,10 @@ Constant *ConstantInt::getFalse(Type *Ty) { return FalseC; } -Constant *ConstantInt::getBool(Type *Ty, bool V) { - return V ? getTrue(Ty) : getFalse(Ty); -} - +Constant *ConstantInt::getBool(Type *Ty, bool V) { + return V ? getTrue(Ty) : getFalse(Ty); +} + // Get a ConstantInt from an APInt. ConstantInt *ConstantInt::get(LLVMContext &Context, const APInt &V) { // get an existing value or the insertion position @@ -928,7 +928,7 @@ Constant *ConstantFP::get(Type *Ty, double V) { APFloat FV(V); bool ignored; - FV.convert(Ty->getScalarType()->getFltSemantics(), + FV.convert(Ty->getScalarType()->getFltSemantics(), APFloat::rmNearestTiesToEven, &ignored); Constant *C = get(Context, FV); @@ -954,7 +954,7 @@ Constant *ConstantFP::get(Type *Ty, const APFloat &V) { Constant *ConstantFP::get(Type *Ty, StringRef Str) { LLVMContext &Context = Ty->getContext(); - APFloat FV(Ty->getScalarType()->getFltSemantics(), Str); + APFloat FV(Ty->getScalarType()->getFltSemantics(), Str); Constant *C = get(Context, FV); // For vectors, broadcast the value. @@ -965,7 +965,7 @@ Constant *ConstantFP::get(Type *Ty, StringRef Str) { } Constant *ConstantFP::getNaN(Type *Ty, bool Negative, uint64_t Payload) { - const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics(); + const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics(); APFloat NaN = APFloat::getNaN(Semantics, Negative, Payload); Constant *C = get(Ty->getContext(), NaN); @@ -976,7 +976,7 @@ Constant *ConstantFP::getNaN(Type *Ty, bool Negative, uint64_t Payload) { } Constant *ConstantFP::getQNaN(Type *Ty, bool Negative, APInt *Payload) { - const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics(); + const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics(); APFloat NaN = APFloat::getQNaN(Semantics, Negative, Payload); Constant *C = get(Ty->getContext(), NaN); @@ -987,7 +987,7 @@ Constant *ConstantFP::getQNaN(Type *Ty, bool Negative, APInt *Payload) { } Constant *ConstantFP::getSNaN(Type *Ty, bool Negative, APInt *Payload) { - const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics(); + const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics(); APFloat NaN = APFloat::getSNaN(Semantics, Negative, Payload); Constant *C = get(Ty->getContext(), NaN); @@ -998,7 +998,7 @@ Constant *ConstantFP::getSNaN(Type *Ty, bool Negative, APInt *Payload) { } Constant *ConstantFP::getNegativeZero(Type *Ty) { - const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics(); + const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics(); APFloat NegZero = APFloat::getZero(Semantics, /*Negative=*/true); Constant *C = get(Ty->getContext(), NegZero); @@ -1024,7 +1024,7 @@ ConstantFP* ConstantFP::get(LLVMContext &Context, const APFloat& V) { std::unique_ptr<ConstantFP> &Slot = pImpl->FPConstants[V]; if (!Slot) { - Type *Ty = Type::getFloatingPointTy(Context, V.getSemantics()); + Type *Ty = Type::getFloatingPointTy(Context, V.getSemantics()); Slot.reset(new ConstantFP(Ty, V)); } @@ -1032,7 +1032,7 @@ ConstantFP* ConstantFP::get(LLVMContext &Context, const APFloat& V) { } Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) { - const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics(); + const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics(); Constant *C = get(Ty->getContext(), APFloat::getInf(Semantics, Negative)); if (VectorType *VTy = dyn_cast<VectorType>(Ty)) @@ -1043,7 +1043,7 @@ Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) { ConstantFP::ConstantFP(Type *Ty, const APFloat &V) : ConstantData(Ty, ConstantFPVal), Val(V) { - assert(&V.getSemantics() == &Ty->getFltSemantics() && + assert(&V.getSemantics() == &Ty->getFltSemantics() && "FP type Mismatch"); } @@ -1087,7 +1087,7 @@ unsigned ConstantAggregateZero::getNumElements() const { if (auto *AT = dyn_cast<ArrayType>(Ty)) return AT->getNumElements(); if (auto *VT = dyn_cast<VectorType>(Ty)) - return cast<FixedVectorType>(VT)->getNumElements(); + return cast<FixedVectorType>(VT)->getNumElements(); return Ty->getStructNumElements(); } @@ -1122,37 +1122,37 @@ unsigned UndefValue::getNumElements() const { if (auto *AT = dyn_cast<ArrayType>(Ty)) return AT->getNumElements(); if (auto *VT = dyn_cast<VectorType>(Ty)) - return cast<FixedVectorType>(VT)->getNumElements(); + return cast<FixedVectorType>(VT)->getNumElements(); return Ty->getStructNumElements(); } //===----------------------------------------------------------------------===// -// PoisonValue Implementation -//===----------------------------------------------------------------------===// - -PoisonValue *PoisonValue::getSequentialElement() const { - if (ArrayType *ATy = dyn_cast<ArrayType>(getType())) - return PoisonValue::get(ATy->getElementType()); - return PoisonValue::get(cast<VectorType>(getType())->getElementType()); -} - -PoisonValue *PoisonValue::getStructElement(unsigned Elt) const { - return PoisonValue::get(getType()->getStructElementType(Elt)); -} - -PoisonValue *PoisonValue::getElementValue(Constant *C) const { - if (isa<ArrayType>(getType()) || isa<VectorType>(getType())) - return getSequentialElement(); - return getStructElement(cast<ConstantInt>(C)->getZExtValue()); -} - -PoisonValue *PoisonValue::getElementValue(unsigned Idx) const { - if (isa<ArrayType>(getType()) || isa<VectorType>(getType())) - return getSequentialElement(); - return getStructElement(Idx); -} - -//===----------------------------------------------------------------------===// +// PoisonValue Implementation +//===----------------------------------------------------------------------===// + +PoisonValue *PoisonValue::getSequentialElement() const { + if (ArrayType *ATy = dyn_cast<ArrayType>(getType())) + return PoisonValue::get(ATy->getElementType()); + return PoisonValue::get(cast<VectorType>(getType())->getElementType()); +} + +PoisonValue *PoisonValue::getStructElement(unsigned Elt) const { + return PoisonValue::get(getType()->getStructElementType(Elt)); +} + +PoisonValue *PoisonValue::getElementValue(Constant *C) const { + if (isa<ArrayType>(getType()) || isa<VectorType>(getType())) + return getSequentialElement(); + return getStructElement(cast<ConstantInt>(C)->getZExtValue()); +} + +PoisonValue *PoisonValue::getElementValue(unsigned Idx) const { + if (isa<ArrayType>(getType()) || isa<VectorType>(getType())) + return getSequentialElement(); + return getStructElement(Idx); +} + +//===----------------------------------------------------------------------===// // ConstantXXX Classes //===----------------------------------------------------------------------===// @@ -1330,7 +1330,7 @@ Constant *ConstantStruct::get(StructType *ST, ArrayRef<Constant*> V) { ConstantVector::ConstantVector(VectorType *T, ArrayRef<Constant *> V) : ConstantAggregate(T, ConstantVectorVal, V) { - assert(V.size() == cast<FixedVectorType>(T)->getNumElements() && + assert(V.size() == cast<FixedVectorType>(T)->getNumElements() && "Invalid initializer for constant vector"); } @@ -1351,20 +1351,20 @@ Constant *ConstantVector::getImpl(ArrayRef<Constant*> V) { Constant *C = V[0]; bool isZero = C->isNullValue(); bool isUndef = isa<UndefValue>(C); - bool isPoison = isa<PoisonValue>(C); + bool isPoison = isa<PoisonValue>(C); if (isZero || isUndef) { for (unsigned i = 1, e = V.size(); i != e; ++i) if (V[i] != C) { - isZero = isUndef = isPoison = false; + isZero = isUndef = isPoison = false; break; } } if (isZero) return ConstantAggregateZero::get(T); - if (isPoison) - return PoisonValue::get(T); + if (isPoison) + return PoisonValue::get(T); if (isUndef) return UndefValue::get(T); @@ -1379,14 +1379,14 @@ Constant *ConstantVector::getImpl(ArrayRef<Constant*> V) { } Constant *ConstantVector::getSplat(ElementCount EC, Constant *V) { - if (!EC.isScalable()) { + if (!EC.isScalable()) { // If this splat is compatible with ConstantDataVector, use it instead of // ConstantVector. if ((isa<ConstantFP>(V) || isa<ConstantInt>(V)) && ConstantDataSequential::isElementTypeCompatible(V->getType())) - return ConstantDataVector::getSplat(EC.getKnownMinValue(), V); + return ConstantDataVector::getSplat(EC.getKnownMinValue(), V); - SmallVector<Constant *, 32> Elts(EC.getKnownMinValue(), V); + SmallVector<Constant *, 32> Elts(EC.getKnownMinValue(), V); return get(Elts); } @@ -1403,7 +1403,7 @@ Constant *ConstantVector::getSplat(ElementCount EC, Constant *V) { Constant *UndefV = UndefValue::get(VTy); V = ConstantExpr::getInsertElement(UndefV, V, ConstantInt::get(I32Ty, 0)); // Build shuffle mask to perform the splat. - SmallVector<int, 8> Zeros(EC.getKnownMinValue(), 0); + SmallVector<int, 8> Zeros(EC.getKnownMinValue(), 0); // Splat. return ConstantExpr::getShuffleVector(V, UndefV, Zeros); } @@ -1528,8 +1528,8 @@ Constant *ConstantExpr::getWithOperands(ArrayRef<Constant *> Ops, Type *Ty, OnlyIfReducedTy); case Instruction::ExtractValue: return ConstantExpr::getExtractValue(Ops[0], getIndices(), OnlyIfReducedTy); - case Instruction::FNeg: - return ConstantExpr::getFNeg(Ops[0]); + case Instruction::FNeg: + return ConstantExpr::getFNeg(Ops[0]); case Instruction::ShuffleVector: return ConstantExpr::getShuffleVector(Ops[0], Ops[1], getShuffleMask(), OnlyIfReducedTy); @@ -1690,7 +1690,7 @@ Constant *Constant::getSplatValue(bool AllowUndefs) const { ConstantInt *Index = dyn_cast<ConstantInt>(IElt->getOperand(2)); if (Index && Index->getValue() == 0 && - llvm::all_of(Mask, [](int I) { return I == 0; })) + llvm::all_of(Mask, [](int I) { return I == 0; })) return SplatVal; } } @@ -1762,28 +1762,28 @@ UndefValue *UndefValue::get(Type *Ty) { /// Remove the constant from the constant table. void UndefValue::destroyConstantImpl() { // Free the constant and any dangling references to it. - if (getValueID() == UndefValueVal) { - getContext().pImpl->UVConstants.erase(getType()); - } else if (getValueID() == PoisonValueVal) { - getContext().pImpl->PVConstants.erase(getType()); - } - llvm_unreachable("Not a undef or a poison!"); -} - -PoisonValue *PoisonValue::get(Type *Ty) { - std::unique_ptr<PoisonValue> &Entry = Ty->getContext().pImpl->PVConstants[Ty]; - if (!Entry) - Entry.reset(new PoisonValue(Ty)); - - return Entry.get(); -} - -/// Remove the constant from the constant table. -void PoisonValue::destroyConstantImpl() { - // Free the constant and any dangling references to it. - getContext().pImpl->PVConstants.erase(getType()); -} - + if (getValueID() == UndefValueVal) { + getContext().pImpl->UVConstants.erase(getType()); + } else if (getValueID() == PoisonValueVal) { + getContext().pImpl->PVConstants.erase(getType()); + } + llvm_unreachable("Not a undef or a poison!"); +} + +PoisonValue *PoisonValue::get(Type *Ty) { + std::unique_ptr<PoisonValue> &Entry = Ty->getContext().pImpl->PVConstants[Ty]; + if (!Entry) + Entry.reset(new PoisonValue(Ty)); + + return Entry.get(); +} + +/// Remove the constant from the constant table. +void PoisonValue::destroyConstantImpl() { + // Free the constant and any dangling references to it. + getContext().pImpl->PVConstants.erase(getType()); +} + BlockAddress *BlockAddress::get(BasicBlock *BB) { assert(BB->getParent() && "Block must have a parent"); return get(BB->getParent(), BB); @@ -1862,58 +1862,58 @@ Value *BlockAddress::handleOperandChangeImpl(Value *From, Value *To) { return nullptr; } -DSOLocalEquivalent *DSOLocalEquivalent::get(GlobalValue *GV) { - DSOLocalEquivalent *&Equiv = GV->getContext().pImpl->DSOLocalEquivalents[GV]; - if (!Equiv) - Equiv = new DSOLocalEquivalent(GV); - - assert(Equiv->getGlobalValue() == GV && - "DSOLocalFunction does not match the expected global value"); - return Equiv; -} - -DSOLocalEquivalent::DSOLocalEquivalent(GlobalValue *GV) - : Constant(GV->getType(), Value::DSOLocalEquivalentVal, &Op<0>(), 1) { - setOperand(0, GV); -} - -/// Remove the constant from the constant table. -void DSOLocalEquivalent::destroyConstantImpl() { - const GlobalValue *GV = getGlobalValue(); - GV->getContext().pImpl->DSOLocalEquivalents.erase(GV); -} - -Value *DSOLocalEquivalent::handleOperandChangeImpl(Value *From, Value *To) { - assert(From == getGlobalValue() && "Changing value does not match operand."); - assert(isa<Constant>(To) && "Can only replace the operands with a constant"); - - // The replacement is with another global value. - if (const auto *ToObj = dyn_cast<GlobalValue>(To)) { - DSOLocalEquivalent *&NewEquiv = - getContext().pImpl->DSOLocalEquivalents[ToObj]; - if (NewEquiv) - return llvm::ConstantExpr::getBitCast(NewEquiv, getType()); - } - - // If the argument is replaced with a null value, just replace this constant - // with a null value. - if (cast<Constant>(To)->isNullValue()) - return To; - - // The replacement could be a bitcast or an alias to another function. We can - // replace it with a bitcast to the dso_local_equivalent of that function. - auto *Func = cast<Function>(To->stripPointerCastsAndAliases()); - DSOLocalEquivalent *&NewEquiv = getContext().pImpl->DSOLocalEquivalents[Func]; - if (NewEquiv) - return llvm::ConstantExpr::getBitCast(NewEquiv, getType()); - - // Replace this with the new one. - getContext().pImpl->DSOLocalEquivalents.erase(getGlobalValue()); - NewEquiv = this; - setOperand(0, Func); - return nullptr; -} - +DSOLocalEquivalent *DSOLocalEquivalent::get(GlobalValue *GV) { + DSOLocalEquivalent *&Equiv = GV->getContext().pImpl->DSOLocalEquivalents[GV]; + if (!Equiv) + Equiv = new DSOLocalEquivalent(GV); + + assert(Equiv->getGlobalValue() == GV && + "DSOLocalFunction does not match the expected global value"); + return Equiv; +} + +DSOLocalEquivalent::DSOLocalEquivalent(GlobalValue *GV) + : Constant(GV->getType(), Value::DSOLocalEquivalentVal, &Op<0>(), 1) { + setOperand(0, GV); +} + +/// Remove the constant from the constant table. +void DSOLocalEquivalent::destroyConstantImpl() { + const GlobalValue *GV = getGlobalValue(); + GV->getContext().pImpl->DSOLocalEquivalents.erase(GV); +} + +Value *DSOLocalEquivalent::handleOperandChangeImpl(Value *From, Value *To) { + assert(From == getGlobalValue() && "Changing value does not match operand."); + assert(isa<Constant>(To) && "Can only replace the operands with a constant"); + + // The replacement is with another global value. + if (const auto *ToObj = dyn_cast<GlobalValue>(To)) { + DSOLocalEquivalent *&NewEquiv = + getContext().pImpl->DSOLocalEquivalents[ToObj]; + if (NewEquiv) + return llvm::ConstantExpr::getBitCast(NewEquiv, getType()); + } + + // If the argument is replaced with a null value, just replace this constant + // with a null value. + if (cast<Constant>(To)->isNullValue()) + return To; + + // The replacement could be a bitcast or an alias to another function. We can + // replace it with a bitcast to the dso_local_equivalent of that function. + auto *Func = cast<Function>(To->stripPointerCastsAndAliases()); + DSOLocalEquivalent *&NewEquiv = getContext().pImpl->DSOLocalEquivalents[Func]; + if (NewEquiv) + return llvm::ConstantExpr::getBitCast(NewEquiv, getType()); + + // Replace this with the new one. + getContext().pImpl->DSOLocalEquivalents.erase(getGlobalValue()); + NewEquiv = this; + setOperand(0, Func); + return nullptr; +} + //---- ConstantExpr::get() implementations. // @@ -2162,8 +2162,8 @@ Constant *ConstantExpr::getPtrToInt(Constant *C, Type *DstTy, "PtrToInt destination must be integer or integer vector"); assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy)); if (isa<VectorType>(C->getType())) - assert(cast<FixedVectorType>(C->getType())->getNumElements() == - cast<FixedVectorType>(DstTy)->getNumElements() && + assert(cast<FixedVectorType>(C->getType())->getNumElements() == + cast<FixedVectorType>(DstTy)->getNumElements() && "Invalid cast between a different number of vector elements"); return getFoldedCast(Instruction::PtrToInt, C, DstTy, OnlyIfReduced); } @@ -2176,8 +2176,8 @@ Constant *ConstantExpr::getIntToPtr(Constant *C, Type *DstTy, "IntToPtr destination must be a pointer or pointer vector"); assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy)); if (isa<VectorType>(C->getType())) - assert(cast<VectorType>(C->getType())->getElementCount() == - cast<VectorType>(DstTy)->getElementCount() && + assert(cast<VectorType>(C->getType())->getElementCount() == + cast<VectorType>(DstTy)->getElementCount() && "Invalid cast between a different number of vector elements"); return getFoldedCast(Instruction::IntToPtr, C, DstTy, OnlyIfReduced); } @@ -2208,8 +2208,8 @@ Constant *ConstantExpr::getAddrSpaceCast(Constant *C, Type *DstTy, Type *MidTy = PointerType::get(DstElemTy, SrcScalarTy->getAddressSpace()); if (VectorType *VT = dyn_cast<VectorType>(DstTy)) { // Handle vectors of pointers. - MidTy = FixedVectorType::get(MidTy, - cast<FixedVectorType>(VT)->getNumElements()); + MidTy = FixedVectorType::get(MidTy, + cast<FixedVectorType>(VT)->getNumElements()); } C = getBitCast(C, MidTy); } @@ -2406,7 +2406,7 @@ Constant *ConstantExpr::getGetElementPtr(Type *Ty, Constant *C, unsigned AS = C->getType()->getPointerAddressSpace(); Type *ReqTy = DestTy->getPointerTo(AS); - auto EltCount = ElementCount::getFixed(0); + auto EltCount = ElementCount::getFixed(0); if (VectorType *VecTy = dyn_cast<VectorType>(C->getType())) EltCount = VecTy->getElementCount(); else @@ -2414,7 +2414,7 @@ Constant *ConstantExpr::getGetElementPtr(Type *Ty, Constant *C, if (VectorType *VecTy = dyn_cast<VectorType>(Idx->getType())) EltCount = VecTy->getElementCount(); - if (EltCount.isNonZero()) + if (EltCount.isNonZero()) ReqTy = VectorType::get(ReqTy, EltCount); if (OnlyIfReducedTy == ReqTy) @@ -2434,7 +2434,7 @@ Constant *ConstantExpr::getGetElementPtr(Type *Ty, Constant *C, if (GTI.isStruct() && Idx->getType()->isVectorTy()) { Idx = Idx->getSplatValue(); - } else if (GTI.isSequential() && EltCount.isNonZero() && + } else if (GTI.isSequential() && EltCount.isNonZero() && !Idx->getType()->isVectorTy()) { Idx = ConstantVector::getSplat(EltCount, Idx); } @@ -2710,11 +2710,11 @@ Constant *ConstantExpr::getXor(Constant *C1, Constant *C2) { return get(Instruction::Xor, C1, C2); } -Constant *ConstantExpr::getUMin(Constant *C1, Constant *C2) { - Constant *Cmp = ConstantExpr::getICmp(CmpInst::ICMP_ULT, C1, C2); - return getSelect(Cmp, C1, C2); -} - +Constant *ConstantExpr::getUMin(Constant *C1, Constant *C2) { + Constant *Cmp = ConstantExpr::getICmp(CmpInst::ICMP_ULT, C1, C2); + return getSelect(Cmp, C1, C2); +} + Constant *ConstantExpr::getShl(Constant *C1, Constant *C2, bool HasNUW, bool HasNSW) { unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | @@ -2732,35 +2732,35 @@ Constant *ConstantExpr::getAShr(Constant *C1, Constant *C2, bool isExact) { isExact ? PossiblyExactOperator::IsExact : 0); } -Constant *ConstantExpr::getExactLogBase2(Constant *C) { - Type *Ty = C->getType(); - const APInt *IVal; - if (match(C, m_APInt(IVal)) && IVal->isPowerOf2()) - return ConstantInt::get(Ty, IVal->logBase2()); - - // FIXME: We can extract pow of 2 of splat constant for scalable vectors. - auto *VecTy = dyn_cast<FixedVectorType>(Ty); - if (!VecTy) - return nullptr; - - SmallVector<Constant *, 4> Elts; - for (unsigned I = 0, E = VecTy->getNumElements(); I != E; ++I) { - Constant *Elt = C->getAggregateElement(I); - if (!Elt) - return nullptr; - // Note that log2(iN undef) is *NOT* iN undef, because log2(iN undef) u< N. - if (isa<UndefValue>(Elt)) { - Elts.push_back(Constant::getNullValue(Ty->getScalarType())); - continue; - } - if (!match(Elt, m_APInt(IVal)) || !IVal->isPowerOf2()) - return nullptr; - Elts.push_back(ConstantInt::get(Ty->getScalarType(), IVal->logBase2())); - } - - return ConstantVector::get(Elts); -} - +Constant *ConstantExpr::getExactLogBase2(Constant *C) { + Type *Ty = C->getType(); + const APInt *IVal; + if (match(C, m_APInt(IVal)) && IVal->isPowerOf2()) + return ConstantInt::get(Ty, IVal->logBase2()); + + // FIXME: We can extract pow of 2 of splat constant for scalable vectors. + auto *VecTy = dyn_cast<FixedVectorType>(Ty); + if (!VecTy) + return nullptr; + + SmallVector<Constant *, 4> Elts; + for (unsigned I = 0, E = VecTy->getNumElements(); I != E; ++I) { + Constant *Elt = C->getAggregateElement(I); + if (!Elt) + return nullptr; + // Note that log2(iN undef) is *NOT* iN undef, because log2(iN undef) u< N. + if (isa<UndefValue>(Elt)) { + Elts.push_back(Constant::getNullValue(Ty->getScalarType())); + continue; + } + if (!match(Elt, m_APInt(IVal)) || !IVal->isPowerOf2()) + return nullptr; + Elts.push_back(ConstantInt::get(Ty->getScalarType(), IVal->logBase2())); + } + + return ConstantVector::get(Elts); +} + Constant *ConstantExpr::getBinOpIdentity(unsigned Opcode, Type *Ty, bool AllowRHSConstant) { assert(Instruction::isBinaryOp(Opcode) && "Only binops allowed"); @@ -2885,7 +2885,7 @@ bool ConstantDataSequential::isElementTypeCompatible(Type *Ty) { unsigned ConstantDataSequential::getNumElements() const { if (ArrayType *AT = dyn_cast<ArrayType>(getType())) return AT->getNumElements(); - return cast<FixedVectorType>(getType())->getNumElements(); + return cast<FixedVectorType>(getType())->getNumElements(); } @@ -2934,57 +2934,57 @@ Constant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) { // body but different types. For example, 0,0,0,1 could be a 4 element array // of i8, or a 1-element array of i32. They'll both end up in the same /// StringMap bucket, linked up by their Next pointers. Walk the list. - std::unique_ptr<ConstantDataSequential> *Entry = &Slot.second; - for (; *Entry; Entry = &(*Entry)->Next) - if ((*Entry)->getType() == Ty) - return Entry->get(); + std::unique_ptr<ConstantDataSequential> *Entry = &Slot.second; + for (; *Entry; Entry = &(*Entry)->Next) + if ((*Entry)->getType() == Ty) + return Entry->get(); // Okay, we didn't get a hit. Create a node of the right class, link it in, // and return it. - if (isa<ArrayType>(Ty)) { - // Use reset because std::make_unique can't access the constructor. - Entry->reset(new ConstantDataArray(Ty, Slot.first().data())); - return Entry->get(); - } + if (isa<ArrayType>(Ty)) { + // Use reset because std::make_unique can't access the constructor. + Entry->reset(new ConstantDataArray(Ty, Slot.first().data())); + return Entry->get(); + } assert(isa<VectorType>(Ty)); - // Use reset because std::make_unique can't access the constructor. - Entry->reset(new ConstantDataVector(Ty, Slot.first().data())); - return Entry->get(); + // Use reset because std::make_unique can't access the constructor. + Entry->reset(new ConstantDataVector(Ty, Slot.first().data())); + return Entry->get(); } void ConstantDataSequential::destroyConstantImpl() { // Remove the constant from the StringMap. - StringMap<std::unique_ptr<ConstantDataSequential>> &CDSConstants = - getType()->getContext().pImpl->CDSConstants; + StringMap<std::unique_ptr<ConstantDataSequential>> &CDSConstants = + getType()->getContext().pImpl->CDSConstants; - auto Slot = CDSConstants.find(getRawDataValues()); + auto Slot = CDSConstants.find(getRawDataValues()); assert(Slot != CDSConstants.end() && "CDS not found in uniquing table"); - std::unique_ptr<ConstantDataSequential> *Entry = &Slot->getValue(); + std::unique_ptr<ConstantDataSequential> *Entry = &Slot->getValue(); // Remove the entry from the hash table. if (!(*Entry)->Next) { // If there is only one value in the bucket (common case) it must be this // entry, and removing the entry should remove the bucket completely. - assert(Entry->get() == this && "Hash mismatch in ConstantDataSequential"); + assert(Entry->get() == this && "Hash mismatch in ConstantDataSequential"); getContext().pImpl->CDSConstants.erase(Slot); - return; - } - - // Otherwise, there are multiple entries linked off the bucket, unlink the - // node we care about but keep the bucket around. - while (true) { - std::unique_ptr<ConstantDataSequential> &Node = *Entry; - assert(Node && "Didn't find entry in its uniquing hash table!"); - // If we found our entry, unlink it from the list and we're done. - if (Node.get() == this) { - Node = std::move(Node->Next); - return; + return; + } + + // Otherwise, there are multiple entries linked off the bucket, unlink the + // node we care about but keep the bucket around. + while (true) { + std::unique_ptr<ConstantDataSequential> &Node = *Entry; + assert(Node && "Didn't find entry in its uniquing hash table!"); + // If we found our entry, unlink it from the list and we're done. + if (Node.get() == this) { + Node = std::move(Node->Next); + return; } - - Entry = &Node->Next; + + Entry = &Node->Next; } } @@ -3135,7 +3135,7 @@ Constant *ConstantDataVector::getSplat(unsigned NumElts, Constant *V) { return getFP(V->getType(), Elts); } } - return ConstantVector::getSplat(ElementCount::getFixed(NumElts), V); + return ConstantVector::getSplat(ElementCount::getFixed(NumElts), V); } @@ -3445,7 +3445,7 @@ Value *ConstantExpr::handleOperandChangeImpl(Value *From, Value *ToV) { } Instruction *ConstantExpr::getAsInstruction() const { - SmallVector<Value *, 4> ValueOperands(operands()); + SmallVector<Value *, 4> ValueOperands(operands()); ArrayRef<Value*> Ops(ValueOperands); switch (getOpcode()) { diff --git a/contrib/libs/llvm12/lib/IR/Core.cpp b/contrib/libs/llvm12/lib/IR/Core.cpp index 039b34ace6..0f3a0b08cf 100644 --- a/contrib/libs/llvm12/lib/IR/Core.cpp +++ b/contrib/libs/llvm12/lib/IR/Core.cpp @@ -145,11 +145,11 @@ LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID, return wrap(Attribute::getWithByValType(Ctx, NULL)); } - if (AttrKind == Attribute::AttrKind::StructRet) { - // Same as byval. - return wrap(Attribute::getWithStructRetType(Ctx, NULL)); - } - + if (AttrKind == Attribute::AttrKind::StructRet) { + // Same as byval. + return wrap(Attribute::getWithStructRetType(Ctx, NULL)); + } + return wrap(Attribute::get(Ctx, AttrKind, Val)); } @@ -164,18 +164,18 @@ uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A) { return Attr.getValueAsInt(); } -LLVMAttributeRef LLVMCreateTypeAttribute(LLVMContextRef C, unsigned KindID, - LLVMTypeRef type_ref) { - auto &Ctx = *unwrap(C); - auto AttrKind = (Attribute::AttrKind)KindID; - return wrap(Attribute::get(Ctx, AttrKind, unwrap(type_ref))); -} - -LLVMTypeRef LLVMGetTypeAttributeValue(LLVMAttributeRef A) { - auto Attr = unwrap(A); - return wrap(Attr.getValueAsType()); -} - +LLVMAttributeRef LLVMCreateTypeAttribute(LLVMContextRef C, unsigned KindID, + LLVMTypeRef type_ref) { + auto &Ctx = *unwrap(C); + auto AttrKind = (Attribute::AttrKind)KindID; + return wrap(Attribute::get(Ctx, AttrKind, unwrap(type_ref))); +} + +LLVMTypeRef LLVMGetTypeAttributeValue(LLVMAttributeRef A) { + auto Attr = unwrap(A); + return wrap(Attr.getValueAsType()); +} + LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C, const char *K, unsigned KLength, const char *V, unsigned VLength) { @@ -206,10 +206,10 @@ LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A) { return unwrap(A).isStringAttribute(); } -LLVMBool LLVMIsTypeAttribute(LLVMAttributeRef A) { - return unwrap(A).isTypeAttribute(); -} - +LLVMBool LLVMIsTypeAttribute(LLVMAttributeRef A) { + return unwrap(A).isTypeAttribute(); +} + char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI) { std::string MsgStorage; raw_string_ostream Stream(MsgStorage); @@ -527,8 +527,8 @@ LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) { return LLVMVectorTypeKind; case Type::X86_MMXTyID: return LLVMX86_MMXTypeKind; - case Type::X86_AMXTyID: - return LLVMX86_AMXTypeKind; + case Type::X86_AMXTyID: + return LLVMX86_AMXTypeKind; case Type::TokenTyID: return LLVMTokenTypeKind; case Type::ScalableVectorTyID: @@ -640,9 +640,9 @@ LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C) { LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C) { return (LLVMTypeRef) Type::getX86_MMXTy(*unwrap(C)); } -LLVMTypeRef LLVMX86AMXTypeInContext(LLVMContextRef C) { - return (LLVMTypeRef) Type::getX86_AMXTy(*unwrap(C)); -} +LLVMTypeRef LLVMX86AMXTypeInContext(LLVMContextRef C) { + return (LLVMTypeRef) Type::getX86_AMXTy(*unwrap(C)); +} LLVMTypeRef LLVMHalfType(void) { return LLVMHalfTypeInContext(LLVMGetGlobalContext()); @@ -668,9 +668,9 @@ LLVMTypeRef LLVMPPCFP128Type(void) { LLVMTypeRef LLVMX86MMXType(void) { return LLVMX86MMXTypeInContext(LLVMGetGlobalContext()); } -LLVMTypeRef LLVMX86AMXType(void) { - return LLVMX86AMXTypeInContext(LLVMGetGlobalContext()); -} +LLVMTypeRef LLVMX86AMXType(void) { + return LLVMX86AMXTypeInContext(LLVMGetGlobalContext()); +} /*--.. Operations on function types ........................................--*/ @@ -762,13 +762,13 @@ LLVMBool LLVMIsLiteralStruct(LLVMTypeRef StructTy) { } LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name) { - return wrap(StructType::getTypeByName(unwrap(M)->getContext(), Name)); -} - -LLVMTypeRef LLVMGetTypeByName2(LLVMContextRef C, const char *Name) { - return wrap(StructType::getTypeByName(*unwrap(C), Name)); + return wrap(StructType::getTypeByName(unwrap(M)->getContext(), Name)); } +LLVMTypeRef LLVMGetTypeByName2(LLVMContextRef C, const char *Name) { + return wrap(StructType::getTypeByName(*unwrap(C), Name)); +} + /*--.. Operations on array, pointer, and vector types (sequence types) .....--*/ void LLVMGetSubtypes(LLVMTypeRef Tp, LLVMTypeRef *Arr) { @@ -791,11 +791,11 @@ LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) { return wrap(FixedVectorType::get(unwrap(ElementType), ElementCount)); } -LLVMTypeRef LLVMScalableVectorType(LLVMTypeRef ElementType, - unsigned ElementCount) { - return wrap(ScalableVectorType::get(unwrap(ElementType), ElementCount)); -} - +LLVMTypeRef LLVMScalableVectorType(LLVMTypeRef ElementType, + unsigned ElementCount) { + return wrap(ScalableVectorType::get(unwrap(ElementType), ElementCount)); +} + LLVMTypeRef LLVMGetElementType(LLVMTypeRef WrappedTy) { auto *Ty = unwrap<Type>(WrappedTy); if (auto *PTy = dyn_cast<PointerType>(Ty)) @@ -818,7 +818,7 @@ unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy) { } unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) { - return unwrap<VectorType>(VectorTy)->getElementCount().getKnownMinValue(); + return unwrap<VectorType>(VectorTy)->getElementCount().getKnownMinValue(); } /*--.. Operations on other types ...........................................--*/ @@ -853,7 +853,7 @@ LLVMTypeRef LLVMTypeOf(LLVMValueRef Val) { LLVMValueKind LLVMGetValueKind(LLVMValueRef Val) { switch(unwrap(Val)->getValueID()) { -#define LLVM_C_API 1 +#define LLVM_C_API 1 #define HANDLE_VALUE(Name) \ case Value::Name##Val: \ return LLVM##Name##ValueKind; @@ -963,7 +963,7 @@ LLVMValueMetadataEntry * LLVMInstructionGetAllMetadataOtherThanDebugLoc(LLVMValueRef Value, size_t *NumEntries) { return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) { - Entries.clear(); + Entries.clear(); unwrap<Instruction>(Value)->getAllMetadata(Entries); }); } @@ -1073,10 +1073,10 @@ LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) { return wrap(UndefValue::get(unwrap(Ty))); } -LLVMValueRef LLVMGetPoison(LLVMTypeRef Ty) { - return wrap(PoisonValue::get(unwrap(Ty))); -} - +LLVMValueRef LLVMGetPoison(LLVMTypeRef Ty) { + return wrap(PoisonValue::get(unwrap(Ty))); +} + LLVMBool LLVMIsConstant(LLVMValueRef Ty) { return isa<Constant>(unwrap(Ty)); } @@ -1091,10 +1091,10 @@ LLVMBool LLVMIsUndef(LLVMValueRef Val) { return isa<UndefValue>(unwrap(Val)); } -LLVMBool LLVMIsPoison(LLVMValueRef Val) { - return isa<PoisonValue>(unwrap(Val)); -} - +LLVMBool LLVMIsPoison(LLVMValueRef Val) { + return isa<PoisonValue>(unwrap(Val)); +} + LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) { return wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty))); } @@ -2081,7 +2081,7 @@ void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes) { LLVMValueMetadataEntry *LLVMGlobalCopyAllMetadata(LLVMValueRef Value, size_t *NumEntries) { return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) { - Entries.clear(); + Entries.clear(); if (Instruction *Instr = dyn_cast<Instruction>(unwrap(Value))) { Instr->getAllMetadata(Entries); } else { diff --git a/contrib/libs/llvm12/lib/IR/DIBuilder.cpp b/contrib/libs/llvm12/lib/IR/DIBuilder.cpp index 5104dc349d..169174544a 100644 --- a/contrib/libs/llvm12/lib/IR/DIBuilder.cpp +++ b/contrib/libs/llvm12/lib/IR/DIBuilder.cpp @@ -267,12 +267,12 @@ DIBasicType *DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits, 0, Encoding, Flags); } -DIStringType *DIBuilder::createStringType(StringRef Name, uint64_t SizeInBits) { - assert(!Name.empty() && "Unable to create type without name"); - return DIStringType::get(VMContext, dwarf::DW_TAG_string_type, Name, - SizeInBits, 0); -} - +DIStringType *DIBuilder::createStringType(StringRef Name, uint64_t SizeInBits) { + assert(!Name.empty() && "Unable to create type without name"); + return DIStringType::get(VMContext, dwarf::DW_TAG_string_type, Name, + SizeInBits, 0); +} + DIDerivedType *DIBuilder::createQualifiedType(unsigned Tag, DIType *FromTy) { return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, FromTy, 0, 0, 0, None, DINode::FlagZero); @@ -525,24 +525,24 @@ DICompositeType *DIBuilder::createEnumerationType( return CTy; } -DICompositeType *DIBuilder::createArrayType( - uint64_t Size, uint32_t AlignInBits, DIType *Ty, DINodeArray Subscripts, - PointerUnion<DIExpression *, DIVariable *> DL, - PointerUnion<DIExpression *, DIVariable *> AS, - PointerUnion<DIExpression *, DIVariable *> AL, - PointerUnion<DIExpression *, DIVariable *> RK) { - auto *R = DICompositeType::get( - VMContext, dwarf::DW_TAG_array_type, "", nullptr, 0, - nullptr, Ty, Size, AlignInBits, 0, DINode::FlagZero, - Subscripts, 0, nullptr, nullptr, "", nullptr, - DL.is<DIExpression *>() ? (Metadata *)DL.get<DIExpression *>() - : (Metadata *)DL.get<DIVariable *>(), - AS.is<DIExpression *>() ? (Metadata *)AS.get<DIExpression *>() - : (Metadata *)AS.get<DIVariable *>(), - AL.is<DIExpression *>() ? (Metadata *)AL.get<DIExpression *>() - : (Metadata *)AL.get<DIVariable *>(), - RK.is<DIExpression *>() ? (Metadata *)RK.get<DIExpression *>() - : (Metadata *)RK.get<DIVariable *>()); +DICompositeType *DIBuilder::createArrayType( + uint64_t Size, uint32_t AlignInBits, DIType *Ty, DINodeArray Subscripts, + PointerUnion<DIExpression *, DIVariable *> DL, + PointerUnion<DIExpression *, DIVariable *> AS, + PointerUnion<DIExpression *, DIVariable *> AL, + PointerUnion<DIExpression *, DIVariable *> RK) { + auto *R = DICompositeType::get( + VMContext, dwarf::DW_TAG_array_type, "", nullptr, 0, + nullptr, Ty, Size, AlignInBits, 0, DINode::FlagZero, + Subscripts, 0, nullptr, nullptr, "", nullptr, + DL.is<DIExpression *>() ? (Metadata *)DL.get<DIExpression *>() + : (Metadata *)DL.get<DIVariable *>(), + AS.is<DIExpression *>() ? (Metadata *)AS.get<DIExpression *>() + : (Metadata *)AS.get<DIVariable *>(), + AL.is<DIExpression *>() ? (Metadata *)AL.get<DIExpression *>() + : (Metadata *)AL.get<DIVariable *>(), + RK.is<DIExpression *>() ? (Metadata *)RK.get<DIExpression *>() + : (Metadata *)RK.get<DIVariable *>()); trackIfUnresolved(R); return R; } @@ -661,18 +661,18 @@ DISubrange *DIBuilder::getOrCreateSubrange(Metadata *CountNode, Metadata *LB, return DISubrange::get(VMContext, CountNode, LB, UB, Stride); } -DIGenericSubrange *DIBuilder::getOrCreateGenericSubrange( - DIGenericSubrange::BoundType CountNode, DIGenericSubrange::BoundType LB, - DIGenericSubrange::BoundType UB, DIGenericSubrange::BoundType Stride) { - auto ConvToMetadata = [&](DIGenericSubrange::BoundType Bound) -> Metadata * { - return Bound.is<DIExpression *>() ? (Metadata *)Bound.get<DIExpression *>() - : (Metadata *)Bound.get<DIVariable *>(); - }; - return DIGenericSubrange::get(VMContext, ConvToMetadata(CountNode), - ConvToMetadata(LB), ConvToMetadata(UB), - ConvToMetadata(Stride)); -} - +DIGenericSubrange *DIBuilder::getOrCreateGenericSubrange( + DIGenericSubrange::BoundType CountNode, DIGenericSubrange::BoundType LB, + DIGenericSubrange::BoundType UB, DIGenericSubrange::BoundType Stride) { + auto ConvToMetadata = [&](DIGenericSubrange::BoundType Bound) -> Metadata * { + return Bound.is<DIExpression *>() ? (Metadata *)Bound.get<DIExpression *>() + : (Metadata *)Bound.get<DIVariable *>(); + }; + return DIGenericSubrange::get(VMContext, ConvToMetadata(CountNode), + ConvToMetadata(LB), ConvToMetadata(UB), + ConvToMetadata(Stride)); +} + static void checkGlobalVariableScope(DIScope *Context) { #ifndef NDEBUG if (auto *CT = @@ -874,10 +874,10 @@ DINamespace *DIBuilder::createNameSpace(DIScope *Scope, StringRef Name, DIModule *DIBuilder::createModule(DIScope *Scope, StringRef Name, StringRef ConfigurationMacros, StringRef IncludePath, StringRef APINotesFile, - DIFile *File, unsigned LineNo, bool IsDecl) { + DIFile *File, unsigned LineNo, bool IsDecl) { return DIModule::get(VMContext, File, getNonCompileUnitScope(Scope), Name, - ConfigurationMacros, IncludePath, APINotesFile, LineNo, - IsDecl); + ConfigurationMacros, IncludePath, APINotesFile, LineNo, + IsDecl); } DILexicalBlockFile *DIBuilder::createLexicalBlockFile(DIScope *Scope, diff --git a/contrib/libs/llvm12/lib/IR/DataLayout.cpp b/contrib/libs/llvm12/lib/IR/DataLayout.cpp index 274ea0aa5f..3a6ae1d647 100644 --- a/contrib/libs/llvm12/lib/IR/DataLayout.cpp +++ b/contrib/libs/llvm12/lib/IR/DataLayout.cpp @@ -27,7 +27,7 @@ #include "llvm/IR/Type.h" #include "llvm/IR/Value.h" #include "llvm/Support/Casting.h" -#include "llvm/Support/Error.h" +#include "llvm/Support/Error.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/TypeSize.h" @@ -65,8 +65,8 @@ StructLayout::StructLayout(StructType *ST, const DataLayout &DL) { StructAlignment = std::max(TyAlign, StructAlignment); MemberOffsets[i] = StructSize; - // Consume space for this data item - StructSize += DL.getTypeAllocSize(Ty).getFixedValue(); + // Consume space for this data item + StructSize += DL.getTypeAllocSize(Ty).getFixedValue(); } // Add padding to the end of the struct so that it could be put in an array @@ -183,7 +183,7 @@ void DataLayout::reset(StringRef Desc) { AllocaAddrSpace = 0; StackNaturalAlign.reset(); ProgramAddrSpace = 0; - DefaultGlobalsAddrSpace = 0; + DefaultGlobalsAddrSpace = 0; FunctionPtrAlign.reset(); TheFunctionPtrAlignType = FunctionPtrAlignType::Independent; ManglingMode = MM_None; @@ -191,80 +191,80 @@ void DataLayout::reset(StringRef Desc) { // Default alignments for (const LayoutAlignElem &E : DefaultAlignments) { - if (Error Err = setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign, - E.PrefAlign, E.TypeBitWidth)) - return report_fatal_error(std::move(Err)); + if (Error Err = setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign, + E.PrefAlign, E.TypeBitWidth)) + return report_fatal_error(std::move(Err)); } - if (Error Err = setPointerAlignment(0, Align(8), Align(8), 8, 8)) - return report_fatal_error(std::move(Err)); - - if (Error Err = parseSpecifier(Desc)) - return report_fatal_error(std::move(Err)); -} - -Expected<DataLayout> DataLayout::parse(StringRef LayoutDescription) { - DataLayout Layout(""); - if (Error Err = Layout.parseSpecifier(LayoutDescription)) - return std::move(Err); - return Layout; -} - -static Error reportError(const Twine &Message) { - return createStringError(inconvertibleErrorCode(), Message); -} - + if (Error Err = setPointerAlignment(0, Align(8), Align(8), 8, 8)) + return report_fatal_error(std::move(Err)); + + if (Error Err = parseSpecifier(Desc)) + return report_fatal_error(std::move(Err)); +} + +Expected<DataLayout> DataLayout::parse(StringRef LayoutDescription) { + DataLayout Layout(""); + if (Error Err = Layout.parseSpecifier(LayoutDescription)) + return std::move(Err); + return Layout; +} + +static Error reportError(const Twine &Message) { + return createStringError(inconvertibleErrorCode(), Message); +} + /// Checked version of split, to ensure mandatory subparts. -static Error split(StringRef Str, char Separator, - std::pair<StringRef, StringRef> &Split) { +static Error split(StringRef Str, char Separator, + std::pair<StringRef, StringRef> &Split) { assert(!Str.empty() && "parse error, string can't be empty here"); - Split = Str.split(Separator); + Split = Str.split(Separator); if (Split.second.empty() && Split.first != Str) - return reportError("Trailing separator in datalayout string"); + return reportError("Trailing separator in datalayout string"); if (!Split.second.empty() && Split.first.empty()) - return reportError("Expected token before separator in datalayout string"); - return Error::success(); + return reportError("Expected token before separator in datalayout string"); + return Error::success(); } /// Get an unsigned integer, including error checks. -template <typename IntTy> static Error getInt(StringRef R, IntTy &Result) { +template <typename IntTy> static Error getInt(StringRef R, IntTy &Result) { bool error = R.getAsInteger(10, Result); (void)error; if (error) - return reportError("not a number, or does not fit in an unsigned int"); - return Error::success(); + return reportError("not a number, or does not fit in an unsigned int"); + return Error::success(); } -/// Get an unsigned integer representing the number of bits and convert it into -/// bytes. Error out of not a byte width multiple. -template <typename IntTy> -static Error getIntInBytes(StringRef R, IntTy &Result) { - if (Error Err = getInt<IntTy>(R, Result)) - return Err; - if (Result % 8) - return reportError("number of bits must be a byte width multiple"); - Result /= 8; - return Error::success(); +/// Get an unsigned integer representing the number of bits and convert it into +/// bytes. Error out of not a byte width multiple. +template <typename IntTy> +static Error getIntInBytes(StringRef R, IntTy &Result) { + if (Error Err = getInt<IntTy>(R, Result)) + return Err; + if (Result % 8) + return reportError("number of bits must be a byte width multiple"); + Result /= 8; + return Error::success(); } -static Error getAddrSpace(StringRef R, unsigned &AddrSpace) { - if (Error Err = getInt(R, AddrSpace)) - return Err; +static Error getAddrSpace(StringRef R, unsigned &AddrSpace) { + if (Error Err = getInt(R, AddrSpace)) + return Err; if (!isUInt<24>(AddrSpace)) - return reportError("Invalid address space, must be a 24-bit integer"); - return Error::success(); + return reportError("Invalid address space, must be a 24-bit integer"); + return Error::success(); } -Error DataLayout::parseSpecifier(StringRef Desc) { +Error DataLayout::parseSpecifier(StringRef Desc) { StringRepresentation = std::string(Desc); while (!Desc.empty()) { // Split at '-'. - std::pair<StringRef, StringRef> Split; - if (Error Err = split(Desc, '-', Split)) - return Err; + std::pair<StringRef, StringRef> Split; + if (Error Err = split(Desc, '-', Split)) + return Err; Desc = Split.second; // Split at ':'. - if (Error Err = split(Split.first, ':', Split)) - return Err; + if (Error Err = split(Split.first, ':', Split)) + return Err; // Aliases used below. StringRef &Tok = Split.first; // Current token. @@ -272,14 +272,14 @@ Error DataLayout::parseSpecifier(StringRef Desc) { if (Tok == "ni") { do { - if (Error Err = split(Rest, ':', Split)) - return Err; + if (Error Err = split(Rest, ':', Split)) + return Err; Rest = Split.second; - unsigned AS; - if (Error Err = getInt(Split.first, AS)) - return Err; + unsigned AS; + if (Error Err = getInt(Split.first, AS)) + return Err; if (AS == 0) - return reportError("Address space 0 can never be non-integral"); + return reportError("Address space 0 can never be non-integral"); NonIntegralAddressSpaces.push_back(AS); } while (!Rest.empty()); @@ -302,36 +302,36 @@ Error DataLayout::parseSpecifier(StringRef Desc) { break; case 'p': { // Address space. - unsigned AddrSpace = 0; - if (!Tok.empty()) - if (Error Err = getInt(Tok, AddrSpace)) - return Err; + unsigned AddrSpace = 0; + if (!Tok.empty()) + if (Error Err = getInt(Tok, AddrSpace)) + return Err; if (!isUInt<24>(AddrSpace)) - return reportError("Invalid address space, must be a 24bit integer"); + return reportError("Invalid address space, must be a 24bit integer"); // Size. if (Rest.empty()) - return reportError( + return reportError( "Missing size specification for pointer in datalayout string"); - if (Error Err = split(Rest, ':', Split)) - return Err; - unsigned PointerMemSize; - if (Error Err = getIntInBytes(Tok, PointerMemSize)) - return Err; + if (Error Err = split(Rest, ':', Split)) + return Err; + unsigned PointerMemSize; + if (Error Err = getIntInBytes(Tok, PointerMemSize)) + return Err; if (!PointerMemSize) - return reportError("Invalid pointer size of 0 bytes"); + return reportError("Invalid pointer size of 0 bytes"); // ABI alignment. if (Rest.empty()) - return reportError( + return reportError( "Missing alignment specification for pointer in datalayout string"); - if (Error Err = split(Rest, ':', Split)) - return Err; - unsigned PointerABIAlign; - if (Error Err = getIntInBytes(Tok, PointerABIAlign)) - return Err; + if (Error Err = split(Rest, ':', Split)) + return Err; + unsigned PointerABIAlign; + if (Error Err = getIntInBytes(Tok, PointerABIAlign)) + return Err; if (!isPowerOf2_64(PointerABIAlign)) - return reportError("Pointer ABI alignment must be a power of 2"); + return reportError("Pointer ABI alignment must be a power of 2"); // Size of index used in GEP for address calculation. // The parameter is optional. By default it is equal to size of pointer. @@ -340,28 +340,28 @@ Error DataLayout::parseSpecifier(StringRef Desc) { // Preferred alignment. unsigned PointerPrefAlign = PointerABIAlign; if (!Rest.empty()) { - if (Error Err = split(Rest, ':', Split)) - return Err; - if (Error Err = getIntInBytes(Tok, PointerPrefAlign)) - return Err; + if (Error Err = split(Rest, ':', Split)) + return Err; + if (Error Err = getIntInBytes(Tok, PointerPrefAlign)) + return Err; if (!isPowerOf2_64(PointerPrefAlign)) - return reportError( - "Pointer preferred alignment must be a power of 2"); + return reportError( + "Pointer preferred alignment must be a power of 2"); // Now read the index. It is the second optional parameter here. if (!Rest.empty()) { - if (Error Err = split(Rest, ':', Split)) - return Err; - if (Error Err = getIntInBytes(Tok, IndexSize)) - return Err; + if (Error Err = split(Rest, ':', Split)) + return Err; + if (Error Err = getIntInBytes(Tok, IndexSize)) + return Err; if (!IndexSize) - return reportError("Invalid index size of 0 bytes"); + return reportError("Invalid index size of 0 bytes"); } } - if (Error Err = setPointerAlignment( - AddrSpace, assumeAligned(PointerABIAlign), - assumeAligned(PointerPrefAlign), PointerMemSize, IndexSize)) - return Err; + if (Error Err = setPointerAlignment( + AddrSpace, assumeAligned(PointerABIAlign), + assumeAligned(PointerPrefAlign), PointerMemSize, IndexSize)) + return Err; break; } case 'i': @@ -378,75 +378,75 @@ Error DataLayout::parseSpecifier(StringRef Desc) { } // Bit size. - unsigned Size = 0; - if (!Tok.empty()) - if (Error Err = getInt(Tok, Size)) - return Err; + unsigned Size = 0; + if (!Tok.empty()) + if (Error Err = getInt(Tok, Size)) + return Err; if (AlignType == AGGREGATE_ALIGN && Size != 0) - return reportError( + return reportError( "Sized aggregate specification in datalayout string"); // ABI alignment. if (Rest.empty()) - return reportError( + return reportError( "Missing alignment specification in datalayout string"); - if (Error Err = split(Rest, ':', Split)) - return Err; - unsigned ABIAlign; - if (Error Err = getIntInBytes(Tok, ABIAlign)) - return Err; + if (Error Err = split(Rest, ':', Split)) + return Err; + unsigned ABIAlign; + if (Error Err = getIntInBytes(Tok, ABIAlign)) + return Err; if (AlignType != AGGREGATE_ALIGN && !ABIAlign) - return reportError( + return reportError( "ABI alignment specification must be >0 for non-aggregate types"); if (!isUInt<16>(ABIAlign)) - return reportError("Invalid ABI alignment, must be a 16bit integer"); + return reportError("Invalid ABI alignment, must be a 16bit integer"); if (ABIAlign != 0 && !isPowerOf2_64(ABIAlign)) - return reportError("Invalid ABI alignment, must be a power of 2"); + return reportError("Invalid ABI alignment, must be a power of 2"); // Preferred alignment. unsigned PrefAlign = ABIAlign; if (!Rest.empty()) { - if (Error Err = split(Rest, ':', Split)) - return Err; - if (Error Err = getIntInBytes(Tok, PrefAlign)) - return Err; + if (Error Err = split(Rest, ':', Split)) + return Err; + if (Error Err = getIntInBytes(Tok, PrefAlign)) + return Err; } if (!isUInt<16>(PrefAlign)) - return reportError( + return reportError( "Invalid preferred alignment, must be a 16bit integer"); if (PrefAlign != 0 && !isPowerOf2_64(PrefAlign)) - return reportError("Invalid preferred alignment, must be a power of 2"); + return reportError("Invalid preferred alignment, must be a power of 2"); - if (Error Err = setAlignment(AlignType, assumeAligned(ABIAlign), - assumeAligned(PrefAlign), Size)) - return Err; + if (Error Err = setAlignment(AlignType, assumeAligned(ABIAlign), + assumeAligned(PrefAlign), Size)) + return Err; break; } case 'n': // Native integer types. while (true) { - unsigned Width; - if (Error Err = getInt(Tok, Width)) - return Err; + unsigned Width; + if (Error Err = getInt(Tok, Width)) + return Err; if (Width == 0) - return reportError( + return reportError( "Zero width native integer type in datalayout string"); LegalIntWidths.push_back(Width); if (Rest.empty()) break; - if (Error Err = split(Rest, ':', Split)) - return Err; + if (Error Err = split(Rest, ':', Split)) + return Err; } break; case 'S': { // Stack natural alignment. - uint64_t Alignment; - if (Error Err = getIntInBytes(Tok, Alignment)) - return Err; + uint64_t Alignment; + if (Error Err = getIntInBytes(Tok, Alignment)) + return Err; if (Alignment != 0 && !llvm::isPowerOf2_64(Alignment)) - return reportError("Alignment is neither 0 nor a power of 2"); + return reportError("Alignment is neither 0 nor a power of 2"); StackNaturalAlign = MaybeAlign(Alignment); break; } @@ -459,44 +459,44 @@ Error DataLayout::parseSpecifier(StringRef Desc) { TheFunctionPtrAlignType = FunctionPtrAlignType::MultipleOfFunctionAlign; break; default: - return reportError("Unknown function pointer alignment type in " + return reportError("Unknown function pointer alignment type in " "datalayout string"); } Tok = Tok.substr(1); - uint64_t Alignment; - if (Error Err = getIntInBytes(Tok, Alignment)) - return Err; + uint64_t Alignment; + if (Error Err = getIntInBytes(Tok, Alignment)) + return Err; if (Alignment != 0 && !llvm::isPowerOf2_64(Alignment)) - return reportError("Alignment is neither 0 nor a power of 2"); + return reportError("Alignment is neither 0 nor a power of 2"); FunctionPtrAlign = MaybeAlign(Alignment); break; } case 'P': { // Function address space. - if (Error Err = getAddrSpace(Tok, ProgramAddrSpace)) - return Err; + if (Error Err = getAddrSpace(Tok, ProgramAddrSpace)) + return Err; break; } case 'A': { // Default stack/alloca address space. - if (Error Err = getAddrSpace(Tok, AllocaAddrSpace)) - return Err; - break; - } - case 'G': { // Default address space for global variables. - if (Error Err = getAddrSpace(Tok, DefaultGlobalsAddrSpace)) - return Err; + if (Error Err = getAddrSpace(Tok, AllocaAddrSpace)) + return Err; break; } + case 'G': { // Default address space for global variables. + if (Error Err = getAddrSpace(Tok, DefaultGlobalsAddrSpace)) + return Err; + break; + } case 'm': if (!Tok.empty()) - return reportError("Unexpected trailing characters after mangling " - "specifier in datalayout string"); + return reportError("Unexpected trailing characters after mangling " + "specifier in datalayout string"); if (Rest.empty()) - return reportError("Expected mangling specifier in datalayout string"); + return reportError("Expected mangling specifier in datalayout string"); if (Rest.size() > 1) - return reportError("Unknown mangling specifier in datalayout string"); + return reportError("Unknown mangling specifier in datalayout string"); switch(Rest[0]) { default: - return reportError("Unknown mangling in datalayout string"); + return reportError("Unknown mangling in datalayout string"); case 'e': ManglingMode = MM_ELF; break; @@ -518,12 +518,12 @@ Error DataLayout::parseSpecifier(StringRef Desc) { } break; default: - return reportError("Unknown specifier in datalayout string"); + return reportError("Unknown specifier in datalayout string"); break; } } - - return Error::success(); + + return Error::success(); } DataLayout::DataLayout(const Module *M) { @@ -537,7 +537,7 @@ bool DataLayout::operator==(const DataLayout &Other) const { AllocaAddrSpace == Other.AllocaAddrSpace && StackNaturalAlign == Other.StackNaturalAlign && ProgramAddrSpace == Other.ProgramAddrSpace && - DefaultGlobalsAddrSpace == Other.DefaultGlobalsAddrSpace && + DefaultGlobalsAddrSpace == Other.DefaultGlobalsAddrSpace && FunctionPtrAlign == Other.FunctionPtrAlign && TheFunctionPtrAlignType == Other.TheFunctionPtrAlignType && ManglingMode == Other.ManglingMode && @@ -556,17 +556,17 @@ DataLayout::findAlignmentLowerBound(AlignTypeEnum AlignType, }); } -Error DataLayout::setAlignment(AlignTypeEnum align_type, Align abi_align, - Align pref_align, uint32_t bit_width) { +Error DataLayout::setAlignment(AlignTypeEnum align_type, Align abi_align, + Align pref_align, uint32_t bit_width) { // AlignmentsTy::ABIAlign and AlignmentsTy::PrefAlign were once stored as // uint16_t, it is unclear if there are requirements for alignment to be less // than 2^16 other than storage. In the meantime we leave the restriction as // an assert. See D67400 for context. assert(Log2(abi_align) < 16 && Log2(pref_align) < 16 && "Alignment too big"); if (!isUInt<24>(bit_width)) - return reportError("Invalid bit width, must be a 24bit integer"); + return reportError("Invalid bit width, must be a 24bit integer"); if (pref_align < abi_align) - return reportError( + return reportError( "Preferred alignment cannot be less than the ABI alignment"); AlignmentsTy::iterator I = findAlignmentLowerBound(align_type, bit_width); @@ -580,35 +580,35 @@ Error DataLayout::setAlignment(AlignTypeEnum align_type, Align abi_align, Alignments.insert(I, LayoutAlignElem::get(align_type, abi_align, pref_align, bit_width)); } - return Error::success(); -} - -const PointerAlignElem & -DataLayout::getPointerAlignElem(uint32_t AddressSpace) const { - if (AddressSpace != 0) { - auto I = lower_bound(Pointers, AddressSpace, - [](const PointerAlignElem &A, uint32_t AddressSpace) { - return A.AddressSpace < AddressSpace; - }); - if (I != Pointers.end() && I->AddressSpace == AddressSpace) - return *I; - } - - assert(Pointers[0].AddressSpace == 0); - return Pointers[0]; -} - -Error DataLayout::setPointerAlignment(uint32_t AddrSpace, Align ABIAlign, - Align PrefAlign, uint32_t TypeByteWidth, - uint32_t IndexWidth) { + return Error::success(); +} + +const PointerAlignElem & +DataLayout::getPointerAlignElem(uint32_t AddressSpace) const { + if (AddressSpace != 0) { + auto I = lower_bound(Pointers, AddressSpace, + [](const PointerAlignElem &A, uint32_t AddressSpace) { + return A.AddressSpace < AddressSpace; + }); + if (I != Pointers.end() && I->AddressSpace == AddressSpace) + return *I; + } + + assert(Pointers[0].AddressSpace == 0); + return Pointers[0]; +} + +Error DataLayout::setPointerAlignment(uint32_t AddrSpace, Align ABIAlign, + Align PrefAlign, uint32_t TypeByteWidth, + uint32_t IndexWidth) { if (PrefAlign < ABIAlign) - return reportError( + return reportError( "Preferred alignment cannot be less than the ABI alignment"); - auto I = lower_bound(Pointers, AddrSpace, - [](const PointerAlignElem &A, uint32_t AddressSpace) { - return A.AddressSpace < AddressSpace; - }); + auto I = lower_bound(Pointers, AddrSpace, + [](const PointerAlignElem &A, uint32_t AddressSpace) { + return A.AddressSpace < AddressSpace; + }); if (I == Pointers.end() || I->AddressSpace != AddrSpace) { Pointers.insert(I, PointerAlignElem::get(AddrSpace, ABIAlign, PrefAlign, TypeByteWidth, IndexWidth)); @@ -618,19 +618,19 @@ Error DataLayout::setPointerAlignment(uint32_t AddrSpace, Align ABIAlign, I->TypeByteWidth = TypeByteWidth; I->IndexWidth = IndexWidth; } - return Error::success(); + return Error::success(); } -Align DataLayout::getIntegerAlignment(uint32_t BitWidth, - bool abi_or_pref) const { - auto I = findAlignmentLowerBound(INTEGER_ALIGN, BitWidth); - // If we don't have an exact match, use alignment of next larger integer - // type. If there is none, use alignment of largest integer type by going - // back one element. - if (I == Alignments.end() || I->AlignType != INTEGER_ALIGN) - --I; - assert(I->AlignType == INTEGER_ALIGN && "Must be integer alignment"); - return abi_or_pref ? I->ABIAlign : I->PrefAlign; +Align DataLayout::getIntegerAlignment(uint32_t BitWidth, + bool abi_or_pref) const { + auto I = findAlignmentLowerBound(INTEGER_ALIGN, BitWidth); + // If we don't have an exact match, use alignment of next larger integer + // type. If there is none, use alignment of largest integer type by going + // back one element. + if (I == Alignments.end() || I->AlignType != INTEGER_ALIGN) + --I; + assert(I->AlignType == INTEGER_ALIGN && "Must be integer alignment"); + return abi_or_pref ? I->ABIAlign : I->PrefAlign; } namespace { @@ -692,15 +692,15 @@ const StructLayout *DataLayout::getStructLayout(StructType *Ty) const { } Align DataLayout::getPointerABIAlignment(unsigned AS) const { - return getPointerAlignElem(AS).ABIAlign; + return getPointerAlignElem(AS).ABIAlign; } Align DataLayout::getPointerPrefAlignment(unsigned AS) const { - return getPointerAlignElem(AS).PrefAlign; + return getPointerAlignElem(AS).PrefAlign; } unsigned DataLayout::getPointerSize(unsigned AS) const { - return getPointerAlignElem(AS).TypeByteWidth; + return getPointerAlignElem(AS).TypeByteWidth; } unsigned DataLayout::getMaxPointerSize() const { @@ -719,7 +719,7 @@ unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const { } unsigned DataLayout::getIndexSize(unsigned AS) const { - return getPointerAlignElem(AS).IndexWidth; + return getPointerAlignElem(AS).IndexWidth; } unsigned DataLayout::getIndexTypeSizeInBits(Type *Ty) const { @@ -758,15 +758,15 @@ Align DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const { // Get the layout annotation... which is lazily created on demand. const StructLayout *Layout = getStructLayout(cast<StructType>(Ty)); - const LayoutAlignElem &AggregateAlign = Alignments[0]; - assert(AggregateAlign.AlignType == AGGREGATE_ALIGN && - "Aggregate alignment must be first alignment entry"); - const Align Align = - abi_or_pref ? AggregateAlign.ABIAlign : AggregateAlign.PrefAlign; + const LayoutAlignElem &AggregateAlign = Alignments[0]; + assert(AggregateAlign.AlignType == AGGREGATE_ALIGN && + "Aggregate alignment must be first alignment entry"); + const Align Align = + abi_or_pref ? AggregateAlign.ABIAlign : AggregateAlign.PrefAlign; return std::max(Align, Layout->getAlignment()); } case Type::IntegerTyID: - return getIntegerAlignment(Ty->getIntegerBitWidth(), abi_or_pref); + return getIntegerAlignment(Ty->getIntegerBitWidth(), abi_or_pref); case Type::HalfTyID: case Type::BFloatTyID: case Type::FloatTyID: @@ -775,44 +775,44 @@ Align DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const { // same size and alignment, so they look the same here. case Type::PPC_FP128TyID: case Type::FP128TyID: - case Type::X86_FP80TyID: { - unsigned BitWidth = getTypeSizeInBits(Ty).getFixedSize(); - auto I = findAlignmentLowerBound(FLOAT_ALIGN, BitWidth); - if (I != Alignments.end() && I->AlignType == FLOAT_ALIGN && - I->TypeBitWidth == BitWidth) - return abi_or_pref ? I->ABIAlign : I->PrefAlign; - - // If we still couldn't find a reasonable default alignment, fall back - // to a simple heuristic that the alignment is the first power of two - // greater-or-equal to the store size of the type. This is a reasonable - // approximation of reality, and if the user wanted something less - // less conservative, they should have specified it explicitly in the data - // layout. - return Align(PowerOf2Ceil(BitWidth / 8)); - } + case Type::X86_FP80TyID: { + unsigned BitWidth = getTypeSizeInBits(Ty).getFixedSize(); + auto I = findAlignmentLowerBound(FLOAT_ALIGN, BitWidth); + if (I != Alignments.end() && I->AlignType == FLOAT_ALIGN && + I->TypeBitWidth == BitWidth) + return abi_or_pref ? I->ABIAlign : I->PrefAlign; + + // If we still couldn't find a reasonable default alignment, fall back + // to a simple heuristic that the alignment is the first power of two + // greater-or-equal to the store size of the type. This is a reasonable + // approximation of reality, and if the user wanted something less + // less conservative, they should have specified it explicitly in the data + // layout. + return Align(PowerOf2Ceil(BitWidth / 8)); + } case Type::X86_MMXTyID: case Type::FixedVectorTyID: - case Type::ScalableVectorTyID: { - unsigned BitWidth = getTypeSizeInBits(Ty).getKnownMinSize(); - auto I = findAlignmentLowerBound(VECTOR_ALIGN, BitWidth); - if (I != Alignments.end() && I->AlignType == VECTOR_ALIGN && - I->TypeBitWidth == BitWidth) - return abi_or_pref ? I->ABIAlign : I->PrefAlign; - - // By default, use natural alignment for vector types. This is consistent - // with what clang and llvm-gcc do. - // TODO: This should probably not be using the alloc size. - unsigned Alignment = - getTypeAllocSize(cast<VectorType>(Ty)->getElementType()); - // We're only calculating a natural alignment, so it doesn't have to be - // based on the full size for scalable vectors. Using the minimum element - // count should be enough here. - Alignment *= cast<VectorType>(Ty)->getElementCount().getKnownMinValue(); - Alignment = PowerOf2Ceil(Alignment); - return Align(Alignment); - } - case Type::X86_AMXTyID: - return Align(64); + case Type::ScalableVectorTyID: { + unsigned BitWidth = getTypeSizeInBits(Ty).getKnownMinSize(); + auto I = findAlignmentLowerBound(VECTOR_ALIGN, BitWidth); + if (I != Alignments.end() && I->AlignType == VECTOR_ALIGN && + I->TypeBitWidth == BitWidth) + return abi_or_pref ? I->ABIAlign : I->PrefAlign; + + // By default, use natural alignment for vector types. This is consistent + // with what clang and llvm-gcc do. + // TODO: This should probably not be using the alloc size. + unsigned Alignment = + getTypeAllocSize(cast<VectorType>(Ty)->getElementType()); + // We're only calculating a natural alignment, so it doesn't have to be + // based on the full size for scalable vectors. Using the minimum element + // count should be enough here. + Alignment *= cast<VectorType>(Ty)->getElementCount().getKnownMinValue(); + Alignment = PowerOf2Ceil(Alignment); + return Align(Alignment); + } + case Type::X86_AMXTyID: + return Align(64); default: llvm_unreachable("Bad type for getAlignment!!!"); } diff --git a/contrib/libs/llvm12/lib/IR/DebugInfo.cpp b/contrib/libs/llvm12/lib/IR/DebugInfo.cpp index d7656b9dd1..9f9d4aad5b 100644 --- a/contrib/libs/llvm12/lib/IR/DebugInfo.cpp +++ b/contrib/libs/llvm12/lib/IR/DebugInfo.cpp @@ -652,8 +652,8 @@ bool llvm::stripNonLineTableDebugInfo(Module &M) { MDNode *InlinedAt = DL.getInlinedAt(); Scope = remap(Scope); InlinedAt = remap(InlinedAt); - return DILocation::get(M.getContext(), DL.getLine(), DL.getCol(), - Scope, InlinedAt); + return DILocation::get(M.getContext(), DL.getLine(), DL.getCol(), + Scope, InlinedAt); }; if (I.getDebugLoc() != DebugLoc()) @@ -697,38 +697,38 @@ void Instruction::applyMergedLocation(const DILocation *LocA, setDebugLoc(DILocation::getMergedLocation(LocA, LocB)); } -void Instruction::updateLocationAfterHoist() { dropLocation(); } - -void Instruction::dropLocation() { - const DebugLoc &DL = getDebugLoc(); - if (!DL) - return; - - // If this isn't a call, drop the location to allow a location from a - // preceding instruction to propagate. - if (!isa<CallBase>(this)) { - setDebugLoc(DebugLoc()); - return; - } - - // Set a line 0 location for calls to preserve scope information in case - // inlining occurs. - DISubprogram *SP = getFunction()->getSubprogram(); - if (SP) - // If a function scope is available, set it on the line 0 location. When - // hoisting a call to a predecessor block, using the function scope avoids - // making it look like the callee was reached earlier than it should be. - setDebugLoc(DILocation::get(getContext(), 0, 0, SP)); - else - // The parent function has no scope. Go ahead and drop the location. If - // the parent function is inlined, and the callee has a subprogram, the - // inliner will attach a location to the call. - // - // One alternative is to set a line 0 location with the existing scope and - // inlinedAt info. The location might be sensitive to when inlining occurs. - setDebugLoc(DebugLoc()); -} - +void Instruction::updateLocationAfterHoist() { dropLocation(); } + +void Instruction::dropLocation() { + const DebugLoc &DL = getDebugLoc(); + if (!DL) + return; + + // If this isn't a call, drop the location to allow a location from a + // preceding instruction to propagate. + if (!isa<CallBase>(this)) { + setDebugLoc(DebugLoc()); + return; + } + + // Set a line 0 location for calls to preserve scope information in case + // inlining occurs. + DISubprogram *SP = getFunction()->getSubprogram(); + if (SP) + // If a function scope is available, set it on the line 0 location. When + // hoisting a call to a predecessor block, using the function scope avoids + // making it look like the callee was reached earlier than it should be. + setDebugLoc(DILocation::get(getContext(), 0, 0, SP)); + else + // The parent function has no scope. Go ahead and drop the location. If + // the parent function is inlined, and the callee has a subprogram, the + // inliner will attach a location to the call. + // + // One alternative is to set a line 0 location with the existing scope and + // inlinedAt info. The location might be sensitive to when inlining occurs. + setDebugLoc(DebugLoc()); +} + //===----------------------------------------------------------------------===// // LLVM C API implementations. //===----------------------------------------------------------------------===// diff --git a/contrib/libs/llvm12/lib/IR/DebugInfoMetadata.cpp b/contrib/libs/llvm12/lib/IR/DebugInfoMetadata.cpp index 77bba9f7ed..fde585a38f 100644 --- a/contrib/libs/llvm12/lib/IR/DebugInfoMetadata.cpp +++ b/contrib/libs/llvm12/lib/IR/DebugInfoMetadata.cpp @@ -133,7 +133,7 @@ const DILocation *DILocation::getMergedLocation(const DILocation *LocA, } Optional<unsigned> DILocation::encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI) { - std::array<unsigned, 3> Components = {BD, DF, CI}; + std::array<unsigned, 3> Components = {BD, DF, CI}; uint64_t RemainingWork = 0U; // We use RemainingWork to figure out if we have no remaining components to // encode. For example: if BD != 0 but DF == 0 && CI == 0, we don't need to @@ -435,84 +435,84 @@ DISubrange::BoundType DISubrange::getStride() const { return BoundType(); } -DIGenericSubrange *DIGenericSubrange::getImpl(LLVMContext &Context, - Metadata *CountNode, Metadata *LB, - Metadata *UB, Metadata *Stride, - StorageType Storage, - bool ShouldCreate) { - DEFINE_GETIMPL_LOOKUP(DIGenericSubrange, (CountNode, LB, UB, Stride)); - Metadata *Ops[] = {CountNode, LB, UB, Stride}; - DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGenericSubrange, Ops); -} - -DIGenericSubrange::BoundType DIGenericSubrange::getCount() const { - Metadata *CB = getRawCountNode(); - if (!CB) - return BoundType(); - - assert((isa<DIVariable>(CB) || isa<DIExpression>(CB)) && - "Count must be signed constant or DIVariable or DIExpression"); - - if (auto *MD = dyn_cast<DIVariable>(CB)) - return BoundType(MD); - - if (auto *MD = dyn_cast<DIExpression>(CB)) - return BoundType(MD); - - return BoundType(); -} - -DIGenericSubrange::BoundType DIGenericSubrange::getLowerBound() const { - Metadata *LB = getRawLowerBound(); - if (!LB) - return BoundType(); - - assert((isa<DIVariable>(LB) || isa<DIExpression>(LB)) && - "LowerBound must be signed constant or DIVariable or DIExpression"); - - if (auto *MD = dyn_cast<DIVariable>(LB)) - return BoundType(MD); - - if (auto *MD = dyn_cast<DIExpression>(LB)) - return BoundType(MD); - - return BoundType(); -} - -DIGenericSubrange::BoundType DIGenericSubrange::getUpperBound() const { - Metadata *UB = getRawUpperBound(); - if (!UB) - return BoundType(); - - assert((isa<DIVariable>(UB) || isa<DIExpression>(UB)) && - "UpperBound must be signed constant or DIVariable or DIExpression"); - - if (auto *MD = dyn_cast<DIVariable>(UB)) - return BoundType(MD); - - if (auto *MD = dyn_cast<DIExpression>(UB)) - return BoundType(MD); - - return BoundType(); -} - -DIGenericSubrange::BoundType DIGenericSubrange::getStride() const { - Metadata *ST = getRawStride(); - if (!ST) - return BoundType(); - - assert((isa<DIVariable>(ST) || isa<DIExpression>(ST)) && - "Stride must be signed constant or DIVariable or DIExpression"); - - if (auto *MD = dyn_cast<DIVariable>(ST)) - return BoundType(MD); - - if (auto *MD = dyn_cast<DIExpression>(ST)) - return BoundType(MD); - - return BoundType(); -} - +DIGenericSubrange *DIGenericSubrange::getImpl(LLVMContext &Context, + Metadata *CountNode, Metadata *LB, + Metadata *UB, Metadata *Stride, + StorageType Storage, + bool ShouldCreate) { + DEFINE_GETIMPL_LOOKUP(DIGenericSubrange, (CountNode, LB, UB, Stride)); + Metadata *Ops[] = {CountNode, LB, UB, Stride}; + DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGenericSubrange, Ops); +} + +DIGenericSubrange::BoundType DIGenericSubrange::getCount() const { + Metadata *CB = getRawCountNode(); + if (!CB) + return BoundType(); + + assert((isa<DIVariable>(CB) || isa<DIExpression>(CB)) && + "Count must be signed constant or DIVariable or DIExpression"); + + if (auto *MD = dyn_cast<DIVariable>(CB)) + return BoundType(MD); + + if (auto *MD = dyn_cast<DIExpression>(CB)) + return BoundType(MD); + + return BoundType(); +} + +DIGenericSubrange::BoundType DIGenericSubrange::getLowerBound() const { + Metadata *LB = getRawLowerBound(); + if (!LB) + return BoundType(); + + assert((isa<DIVariable>(LB) || isa<DIExpression>(LB)) && + "LowerBound must be signed constant or DIVariable or DIExpression"); + + if (auto *MD = dyn_cast<DIVariable>(LB)) + return BoundType(MD); + + if (auto *MD = dyn_cast<DIExpression>(LB)) + return BoundType(MD); + + return BoundType(); +} + +DIGenericSubrange::BoundType DIGenericSubrange::getUpperBound() const { + Metadata *UB = getRawUpperBound(); + if (!UB) + return BoundType(); + + assert((isa<DIVariable>(UB) || isa<DIExpression>(UB)) && + "UpperBound must be signed constant or DIVariable or DIExpression"); + + if (auto *MD = dyn_cast<DIVariable>(UB)) + return BoundType(MD); + + if (auto *MD = dyn_cast<DIExpression>(UB)) + return BoundType(MD); + + return BoundType(); +} + +DIGenericSubrange::BoundType DIGenericSubrange::getStride() const { + Metadata *ST = getRawStride(); + if (!ST) + return BoundType(); + + assert((isa<DIVariable>(ST) || isa<DIExpression>(ST)) && + "Stride must be signed constant or DIVariable or DIExpression"); + + if (auto *MD = dyn_cast<DIVariable>(ST)) + return BoundType(MD); + + if (auto *MD = dyn_cast<DIExpression>(ST)) + return BoundType(MD); + + return BoundType(); +} + DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, const APInt &Value, bool IsUnsigned, MDString *Name, StorageType Storage, bool ShouldCreate) { @@ -548,20 +548,20 @@ Optional<DIBasicType::Signedness> DIBasicType::getSignedness() const { } } -DIStringType *DIStringType::getImpl(LLVMContext &Context, unsigned Tag, - MDString *Name, Metadata *StringLength, - Metadata *StringLengthExp, - uint64_t SizeInBits, uint32_t AlignInBits, - unsigned Encoding, StorageType Storage, - bool ShouldCreate) { - assert(isCanonical(Name) && "Expected canonical MDString"); - DEFINE_GETIMPL_LOOKUP(DIStringType, (Tag, Name, StringLength, StringLengthExp, - SizeInBits, AlignInBits, Encoding)); - Metadata *Ops[] = {nullptr, nullptr, Name, StringLength, StringLengthExp}; - DEFINE_GETIMPL_STORE(DIStringType, (Tag, SizeInBits, AlignInBits, Encoding), - Ops); -} - +DIStringType *DIStringType::getImpl(LLVMContext &Context, unsigned Tag, + MDString *Name, Metadata *StringLength, + Metadata *StringLengthExp, + uint64_t SizeInBits, uint32_t AlignInBits, + unsigned Encoding, StorageType Storage, + bool ShouldCreate) { + assert(isCanonical(Name) && "Expected canonical MDString"); + DEFINE_GETIMPL_LOOKUP(DIStringType, (Tag, Name, StringLength, StringLengthExp, + SizeInBits, AlignInBits, Encoding)); + Metadata *Ops[] = {nullptr, nullptr, Name, StringLength, StringLengthExp}; + DEFINE_GETIMPL_STORE(DIStringType, (Tag, SizeInBits, AlignInBits, Encoding), + Ops); +} + DIDerivedType *DIDerivedType::getImpl( LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, @@ -585,20 +585,20 @@ DICompositeType *DICompositeType::getImpl( uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, Metadata *TemplateParams, MDString *Identifier, Metadata *Discriminator, - Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, - Metadata *Rank, StorageType Storage, bool ShouldCreate) { + Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, + Metadata *Rank, StorageType Storage, bool ShouldCreate) { assert(isCanonical(Name) && "Expected canonical MDString"); // Keep this in sync with buildODRType. - DEFINE_GETIMPL_LOOKUP( - DICompositeType, - (Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits, - OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams, - Identifier, Discriminator, DataLocation, Associated, Allocated, Rank)); + DEFINE_GETIMPL_LOOKUP( + DICompositeType, + (Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits, + OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams, + Identifier, Discriminator, DataLocation, Associated, Allocated, Rank)); Metadata *Ops[] = {File, Scope, Name, BaseType, Elements, VTableHolder, TemplateParams, Identifier, - Discriminator, DataLocation, Associated, Allocated, - Rank}; + Discriminator, DataLocation, Associated, Allocated, + Rank}; DEFINE_GETIMPL_STORE(DICompositeType, (Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits, Flags), Ops); @@ -610,8 +610,8 @@ DICompositeType *DICompositeType::buildODRType( uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator, - Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, - Metadata *Rank) { + Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, + Metadata *Rank) { assert(!Identifier.getString().empty() && "Expected valid identifier"); if (!Context.isODRUniquingDebugTypes()) return nullptr; @@ -621,7 +621,7 @@ DICompositeType *DICompositeType::buildODRType( Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams, &Identifier, Discriminator, - DataLocation, Associated, Allocated, Rank); + DataLocation, Associated, Allocated, Rank); // Only mutate CT if it's a forward declaration and the new operands aren't. assert(CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?"); @@ -633,8 +633,8 @@ DICompositeType *DICompositeType::buildODRType( Flags); Metadata *Ops[] = {File, Scope, Name, BaseType, Elements, VTableHolder, TemplateParams, &Identifier, - Discriminator, DataLocation, Associated, Allocated, - Rank}; + Discriminator, DataLocation, Associated, Allocated, + Rank}; assert((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && "Mismatched number of operands"); for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I) @@ -649,8 +649,8 @@ DICompositeType *DICompositeType::getODRType( uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator, - Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, - Metadata *Rank) { + Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, + Metadata *Rank) { assert(!Identifier.getString().empty() && "Expected valid identifier"); if (!Context.isODRUniquingDebugTypes()) return nullptr; @@ -659,8 +659,8 @@ DICompositeType *DICompositeType::getODRType( CT = DICompositeType::getDistinct( Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, - TemplateParams, &Identifier, Discriminator, DataLocation, Associated, - Allocated, Rank); + TemplateParams, &Identifier, Discriminator, DataLocation, Associated, + Allocated, Rank); return CT; } @@ -926,14 +926,14 @@ DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *File, Metadata *Scope, MDString *Name, MDString *ConfigurationMacros, MDString *IncludePath, MDString *APINotesFile, - unsigned LineNo, bool IsDecl, StorageType Storage, + unsigned LineNo, bool IsDecl, StorageType Storage, bool ShouldCreate) { assert(isCanonical(Name) && "Expected canonical MDString"); DEFINE_GETIMPL_LOOKUP(DIModule, (File, Scope, Name, ConfigurationMacros, - IncludePath, APINotesFile, LineNo, IsDecl)); + IncludePath, APINotesFile, LineNo, IsDecl)); Metadata *Ops[] = {File, Scope, Name, ConfigurationMacros, IncludePath, APINotesFile}; - DEFINE_GETIMPL_STORE(DIModule, (LineNo, IsDecl), Ops); + DEFINE_GETIMPL_STORE(DIModule, (LineNo, IsDecl), Ops); } DITemplateTypeParameter * @@ -1114,7 +1114,7 @@ bool DIExpression::isValid() const { return I->get() == expr_op_begin()->get() && I->getArg(0) == 1 && getNumElements() == 2; } - case dwarf::DW_OP_LLVM_implicit_pointer: + case dwarf::DW_OP_LLVM_implicit_pointer: case dwarf::DW_OP_LLVM_convert: case dwarf::DW_OP_LLVM_tag_offset: case dwarf::DW_OP_constu: @@ -1139,8 +1139,8 @@ bool DIExpression::isValid() const { case dwarf::DW_OP_regx: case dwarf::DW_OP_bregx: case dwarf::DW_OP_push_object_address: - case dwarf::DW_OP_over: - case dwarf::DW_OP_consts: + case dwarf::DW_OP_over: + case dwarf::DW_OP_consts: break; } } @@ -1414,15 +1414,15 @@ bool DIExpression::isConstant() const { return true; } -bool DIExpression::isSignedConstant() const { - // Recognize DW_OP_consts C - if (getNumElements() != 2) - return false; - if (getElement(0) != dwarf::DW_OP_consts) - return false; - return true; -} - +bool DIExpression::isSignedConstant() const { + // Recognize DW_OP_consts C + if (getNumElements() != 2) + return false; + if (getElement(0) != dwarf::DW_OP_consts) + return false; + return true; +} + DIExpression::ExtOps DIExpression::getExtOps(unsigned FromSize, unsigned ToSize, bool Signed) { dwarf::TypeKind TK = Signed ? dwarf::DW_ATE_signed : dwarf::DW_ATE_unsigned; diff --git a/contrib/libs/llvm12/lib/IR/DebugLoc.cpp b/contrib/libs/llvm12/lib/IR/DebugLoc.cpp index 993f3a39e6..5ea0145aff 100644 --- a/contrib/libs/llvm12/lib/IR/DebugLoc.cpp +++ b/contrib/libs/llvm12/lib/IR/DebugLoc.cpp @@ -50,7 +50,7 @@ DebugLoc DebugLoc::getFnDebugLoc() const { // FIXME: Add a method on \a DILocation that does this work. const MDNode *Scope = getInlinedAtScope(); if (auto *SP = getDISubprogram(Scope)) - return DILocation::get(SP->getContext(), SP->getScopeLine(), 0, SP); + return DILocation::get(SP->getContext(), SP->getScopeLine(), 0, SP); return DebugLoc(); } @@ -70,7 +70,7 @@ void DebugLoc::setImplicitCode(bool ImplicitCode) { DebugLoc DebugLoc::appendInlinedAt(const DebugLoc &DL, DILocation *InlinedAt, LLVMContext &Ctx, - DenseMap<const MDNode *, MDNode *> &Cache) { + DenseMap<const MDNode *, MDNode *> &Cache) { SmallVector<DILocation *, 3> InlinedAtLocations; DILocation *Last = InlinedAt; DILocation *CurInlinedAt = DL; diff --git a/contrib/libs/llvm12/lib/IR/DiagnosticInfo.cpp b/contrib/libs/llvm12/lib/IR/DiagnosticInfo.cpp index 8820a79421..1ca85a3ec4 100644 --- a/contrib/libs/llvm12/lib/IR/DiagnosticInfo.cpp +++ b/contrib/libs/llvm12/lib/IR/DiagnosticInfo.cpp @@ -32,7 +32,7 @@ #include "llvm/Support/Casting.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/ErrorHandling.h" -#include "llvm/Support/InstructionCost.h" +#include "llvm/Support/InstructionCost.h" #include "llvm/Support/Path.h" #include "llvm/Support/Regex.h" #include "llvm/Support/ScopedPrinter.h" @@ -214,20 +214,20 @@ DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, unsigned long long N) : Key(std::string(Key)), Val(utostr(N)) {} -DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, - ElementCount EC) - : Key(std::string(Key)) { - raw_string_ostream OS(Val); - EC.print(OS); -} - -DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, - InstructionCost C) - : Key(std::string(Key)) { - raw_string_ostream OS(Val); - C.print(OS); -} - +DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, + ElementCount EC) + : Key(std::string(Key)) { + raw_string_ostream OS(Val); + EC.print(OS); +} + +DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, + InstructionCost C) + : Key(std::string(Key)) { + raw_string_ostream OS(Val); + C.print(OS); +} + DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, DebugLoc Loc) : Key(std::string(Key)), Loc(Loc) { if (Loc) { diff --git a/contrib/libs/llvm12/lib/IR/Dominators.cpp b/contrib/libs/llvm12/lib/IR/Dominators.cpp index fbc28c202a..3bcd512283 100644 --- a/contrib/libs/llvm12/lib/IR/Dominators.cpp +++ b/contrib/libs/llvm12/lib/IR/Dominators.cpp @@ -90,11 +90,11 @@ template void llvm::DomTreeBuilder::DeleteEdge<DomTreeBuilder::BBPostDomTree>( DomTreeBuilder::BBPostDomTree &DT, BasicBlock *From, BasicBlock *To); template void llvm::DomTreeBuilder::ApplyUpdates<DomTreeBuilder::BBDomTree>( - DomTreeBuilder::BBDomTree &DT, DomTreeBuilder::BBDomTreeGraphDiff &, - DomTreeBuilder::BBDomTreeGraphDiff *); + DomTreeBuilder::BBDomTree &DT, DomTreeBuilder::BBDomTreeGraphDiff &, + DomTreeBuilder::BBDomTreeGraphDiff *); template void llvm::DomTreeBuilder::ApplyUpdates<DomTreeBuilder::BBPostDomTree>( - DomTreeBuilder::BBPostDomTree &DT, DomTreeBuilder::BBPostDomTreeGraphDiff &, - DomTreeBuilder::BBPostDomTreeGraphDiff *); + DomTreeBuilder::BBPostDomTree &DT, DomTreeBuilder::BBPostDomTreeGraphDiff &, + DomTreeBuilder::BBPostDomTreeGraphDiff *); template bool llvm::DomTreeBuilder::Verify<DomTreeBuilder::BBDomTree>( const DomTreeBuilder::BBDomTree &DT, @@ -115,15 +115,15 @@ bool DominatorTree::invalidate(Function &F, const PreservedAnalyses &PA, // dominates - Return true if Def dominates a use in User. This performs // the special checks necessary if Def and User are in the same basic block. // Note that Def doesn't dominate a use in Def itself! -bool DominatorTree::dominates(const Value *DefV, +bool DominatorTree::dominates(const Value *DefV, const Instruction *User) const { - const Instruction *Def = dyn_cast<Instruction>(DefV); - if (!Def) { - assert((isa<Argument>(DefV) || isa<Constant>(DefV)) && - "Should be called with an instruction, argument or constant"); - return true; // Arguments and constants dominate everything. - } - + const Instruction *Def = dyn_cast<Instruction>(DefV); + if (!Def) { + assert((isa<Argument>(DefV) || isa<Constant>(DefV)) && + "Should be called with an instruction, argument or constant"); + return true; // Arguments and constants dominate everything. + } + const BasicBlock *UseBB = User->getParent(); const BasicBlock *DefBB = Def->getParent(); @@ -257,14 +257,14 @@ bool DominatorTree::dominates(const BasicBlockEdge &BBE, const Use &U) const { return dominates(BBE, UseBB); } -bool DominatorTree::dominates(const Value *DefV, const Use &U) const { - const Instruction *Def = dyn_cast<Instruction>(DefV); - if (!Def) { - assert((isa<Argument>(DefV) || isa<Constant>(DefV)) && - "Should be called with an instruction, argument or constant"); - return true; // Arguments and constants dominate everything. - } - +bool DominatorTree::dominates(const Value *DefV, const Use &U) const { + const Instruction *Def = dyn_cast<Instruction>(DefV); + if (!Def) { + assert((isa<Argument>(DefV) || isa<Constant>(DefV)) && + "Should be called with an instruction, argument or constant"); + return true; // Arguments and constants dominate everything. + } + Instruction *UserInst = cast<Instruction>(U.getUser()); const BasicBlock *DefBB = Def->getParent(); diff --git a/contrib/libs/llvm12/lib/IR/Function.cpp b/contrib/libs/llvm12/lib/IR/Function.cpp index 17247123f8..42c226de9d 100644 --- a/contrib/libs/llvm12/lib/IR/Function.cpp +++ b/contrib/libs/llvm12/lib/IR/Function.cpp @@ -43,7 +43,7 @@ #include "llvm/IR/IntrinsicsR600.h" #include "llvm/IR/IntrinsicsRISCV.h" #include "llvm/IR/IntrinsicsS390.h" -#include "llvm/IR/IntrinsicsVE.h" +#include "llvm/IR/IntrinsicsVE.h" #include "llvm/IR/IntrinsicsWebAssembly.h" #include "llvm/IR/IntrinsicsX86.h" #include "llvm/IR/IntrinsicsXCore.h" @@ -87,11 +87,11 @@ void Argument::setParent(Function *parent) { Parent = parent; } -bool Argument::hasNonNullAttr(bool AllowUndefOrPoison) const { +bool Argument::hasNonNullAttr(bool AllowUndefOrPoison) const { if (!getType()->isPointerTy()) return false; - if (getParent()->hasParamAttribute(getArgNo(), Attribute::NonNull) && - (AllowUndefOrPoison || - getParent()->hasParamAttribute(getArgNo(), Attribute::NoUndef))) + if (getParent()->hasParamAttribute(getArgNo(), Attribute::NonNull) && + (AllowUndefOrPoison || + getParent()->hasParamAttribute(getArgNo(), Attribute::NoUndef))) return true; else if (getDereferenceableBytes() > 0 && !NullPointerIsDefined(getParent(), @@ -105,12 +105,12 @@ bool Argument::hasByValAttr() const { return hasAttribute(Attribute::ByVal); } -bool Argument::hasByRefAttr() const { - if (!getType()->isPointerTy()) - return false; - return hasAttribute(Attribute::ByRef); -} - +bool Argument::hasByRefAttr() const { + if (!getType()->isPointerTy()) + return false; + return hasAttribute(Attribute::ByRef); +} + bool Argument::hasSwiftSelfAttr() const { return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftSelf); } @@ -130,7 +130,7 @@ bool Argument::hasPreallocatedAttr() const { return hasAttribute(Attribute::Preallocated); } -bool Argument::hasPassPointeeByValueCopyAttr() const { +bool Argument::hasPassPointeeByValueCopyAttr() const { if (!getType()->isPointerTy()) return false; AttributeList Attrs = getParent()->getAttributes(); return Attrs.hasParamAttribute(getArgNo(), Attribute::ByVal) || @@ -138,54 +138,54 @@ bool Argument::hasPassPointeeByValueCopyAttr() const { Attrs.hasParamAttribute(getArgNo(), Attribute::Preallocated); } -bool Argument::hasPointeeInMemoryValueAttr() const { - if (!getType()->isPointerTy()) - return false; - AttributeList Attrs = getParent()->getAttributes(); - return Attrs.hasParamAttribute(getArgNo(), Attribute::ByVal) || - Attrs.hasParamAttribute(getArgNo(), Attribute::StructRet) || - Attrs.hasParamAttribute(getArgNo(), Attribute::InAlloca) || - Attrs.hasParamAttribute(getArgNo(), Attribute::Preallocated) || - Attrs.hasParamAttribute(getArgNo(), Attribute::ByRef); -} - -/// For a byval, sret, inalloca, or preallocated parameter, get the in-memory -/// parameter type. -static Type *getMemoryParamAllocType(AttributeSet ParamAttrs, Type *ArgTy) { +bool Argument::hasPointeeInMemoryValueAttr() const { + if (!getType()->isPointerTy()) + return false; + AttributeList Attrs = getParent()->getAttributes(); + return Attrs.hasParamAttribute(getArgNo(), Attribute::ByVal) || + Attrs.hasParamAttribute(getArgNo(), Attribute::StructRet) || + Attrs.hasParamAttribute(getArgNo(), Attribute::InAlloca) || + Attrs.hasParamAttribute(getArgNo(), Attribute::Preallocated) || + Attrs.hasParamAttribute(getArgNo(), Attribute::ByRef); +} + +/// For a byval, sret, inalloca, or preallocated parameter, get the in-memory +/// parameter type. +static Type *getMemoryParamAllocType(AttributeSet ParamAttrs, Type *ArgTy) { // FIXME: All the type carrying attributes are mutually exclusive, so there // should be a single query to get the stored type that handles any of them. if (Type *ByValTy = ParamAttrs.getByValType()) - return ByValTy; - if (Type *ByRefTy = ParamAttrs.getByRefType()) - return ByRefTy; + return ByValTy; + if (Type *ByRefTy = ParamAttrs.getByRefType()) + return ByRefTy; if (Type *PreAllocTy = ParamAttrs.getPreallocatedType()) - return PreAllocTy; + return PreAllocTy; - // FIXME: sret and inalloca always depends on pointee element type. It's also - // possible for byval to miss it. + // FIXME: sret and inalloca always depends on pointee element type. It's also + // possible for byval to miss it. if (ParamAttrs.hasAttribute(Attribute::InAlloca) || ParamAttrs.hasAttribute(Attribute::ByVal) || - ParamAttrs.hasAttribute(Attribute::StructRet) || + ParamAttrs.hasAttribute(Attribute::StructRet) || ParamAttrs.hasAttribute(Attribute::Preallocated)) - return cast<PointerType>(ArgTy)->getElementType(); - - return nullptr; -} - -uint64_t Argument::getPassPointeeByValueCopySize(const DataLayout &DL) const { - AttributeSet ParamAttrs = - getParent()->getAttributes().getParamAttributes(getArgNo()); - if (Type *MemTy = getMemoryParamAllocType(ParamAttrs, getType())) - return DL.getTypeAllocSize(MemTy); + return cast<PointerType>(ArgTy)->getElementType(); + + return nullptr; +} + +uint64_t Argument::getPassPointeeByValueCopySize(const DataLayout &DL) const { + AttributeSet ParamAttrs = + getParent()->getAttributes().getParamAttributes(getArgNo()); + if (Type *MemTy = getMemoryParamAllocType(ParamAttrs, getType())) + return DL.getTypeAllocSize(MemTy); return 0; } -Type *Argument::getPointeeInMemoryValueType() const { - AttributeSet ParamAttrs = - getParent()->getAttributes().getParamAttributes(getArgNo()); - return getMemoryParamAllocType(ParamAttrs, getType()); -} - +Type *Argument::getPointeeInMemoryValueType() const { + AttributeSet ParamAttrs = + getParent()->getAttributes().getParamAttributes(getArgNo()); + return getMemoryParamAllocType(ParamAttrs, getType()); +} + unsigned Argument::getParamAlignment() const { assert(getType()->isPointerTy() && "Only pointers have alignments"); return getParent()->getParamAlignment(getArgNo()); @@ -201,16 +201,16 @@ Type *Argument::getParamByValType() const { return getParent()->getParamByValType(getArgNo()); } -Type *Argument::getParamStructRetType() const { - assert(getType()->isPointerTy() && "Only pointers have sret types"); - return getParent()->getParamStructRetType(getArgNo()); -} - -Type *Argument::getParamByRefType() const { - assert(getType()->isPointerTy() && "Only pointers have byval types"); - return getParent()->getParamByRefType(getArgNo()); -} - +Type *Argument::getParamStructRetType() const { + assert(getType()->isPointerTy() && "Only pointers have sret types"); + return getParent()->getParamStructRetType(getArgNo()); +} + +Type *Argument::getParamByRefType() const { + assert(getType()->isPointerTy() && "Only pointers have byval types"); + return getParent()->getParamByRefType(getArgNo()); +} + uint64_t Argument::getDereferenceableBytes() const { assert(getType()->isPointerTy() && "Only pointers have dereferenceable bytes"); @@ -580,21 +580,21 @@ void Function::addDereferenceableOrNullParamAttr(unsigned ArgNo, setAttributes(PAL); } -DenormalMode Function::getDenormalMode(const fltSemantics &FPType) const { - if (&FPType == &APFloat::IEEEsingle()) { - Attribute Attr = getFnAttribute("denormal-fp-math-f32"); - StringRef Val = Attr.getValueAsString(); - if (!Val.empty()) - return parseDenormalFPAttribute(Val); - - // If the f32 variant of the attribute isn't specified, try to use the - // generic one. - } - - Attribute Attr = getFnAttribute("denormal-fp-math"); - return parseDenormalFPAttribute(Attr.getValueAsString()); -} - +DenormalMode Function::getDenormalMode(const fltSemantics &FPType) const { + if (&FPType == &APFloat::IEEEsingle()) { + Attribute Attr = getFnAttribute("denormal-fp-math-f32"); + StringRef Val = Attr.getValueAsString(); + if (!Val.empty()) + return parseDenormalFPAttribute(Val); + + // If the f32 variant of the attribute isn't specified, try to use the + // generic one. + } + + Attribute Attr = getFnAttribute("denormal-fp-math"); + return parseDenormalFPAttribute(Attr.getValueAsString()); +} + const std::string &Function::getGC() const { assert(hasGC() && "Function has no collector"); return getContext().getGC(*this); @@ -612,12 +612,12 @@ void Function::clearGC() { setValueSubclassDataBit(14, false); } -bool Function::hasStackProtectorFnAttr() const { - return hasFnAttribute(Attribute::StackProtect) || - hasFnAttribute(Attribute::StackProtectStrong) || - hasFnAttribute(Attribute::StackProtectReq); -} - +bool Function::hasStackProtectorFnAttr() const { + return hasFnAttribute(Attribute::StackProtect) || + hasFnAttribute(Attribute::StackProtectStrong) || + hasFnAttribute(Attribute::StackProtectReq); +} + /// Copy all additional attributes (those not needed to create a Function) from /// the Function Src to this one. void Function::copyAttributesFrom(const Function *Src) { @@ -649,14 +649,14 @@ static const char * const IntrinsicNameTable[] = { #include "llvm/IR/IntrinsicImpl.inc" #undef GET_INTRINSIC_TARGET_DATA -bool Function::isTargetIntrinsic(Intrinsic::ID IID) { - return IID > TargetInfos[0].Count; -} - -bool Function::isTargetIntrinsic() const { - return isTargetIntrinsic(IntID); -} - +bool Function::isTargetIntrinsic(Intrinsic::ID IID) { + return IID > TargetInfos[0].Count; +} + +bool Function::isTargetIntrinsic() const { + return isTargetIntrinsic(IntID); +} + /// Find the segment of \c IntrinsicNameTable for intrinsics with the same /// target as \c Name, or the generic table if \c Name is not target specific. /// @@ -749,10 +749,10 @@ static std::string getMangledTypeStr(Type* Ty) { Result += "f"; } else if (VectorType* VTy = dyn_cast<VectorType>(Ty)) { ElementCount EC = VTy->getElementCount(); - if (EC.isScalable()) + if (EC.isScalable()) Result += "nx"; - Result += "v" + utostr(EC.getKnownMinValue()) + - getMangledTypeStr(VTy->getElementType()); + Result += "v" + utostr(EC.getKnownMinValue()) + + getMangledTypeStr(VTy->getElementType()); } else if (Ty) { switch (Ty->getTypeID()) { default: llvm_unreachable("Unhandled type"); @@ -766,7 +766,7 @@ static std::string getMangledTypeStr(Type* Ty) { case Type::FP128TyID: Result += "f128"; break; case Type::PPC_FP128TyID: Result += "ppcf128"; break; case Type::X86_MMXTyID: Result += "x86mmx"; break; - case Type::X86_AMXTyID: Result += "x86amx"; break; + case Type::X86_AMXTyID: Result += "x86amx"; break; case Type::IntegerTyID: Result += "i" + utostr(cast<IntegerType>(Ty)->getBitWidth()); break; @@ -784,8 +784,8 @@ StringRef Intrinsic::getName(ID id) { std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) { assert(id < num_intrinsics && "Invalid intrinsic ID!"); - assert((Tys.empty() || Intrinsic::isOverloaded(id)) && - "This version of getName is for overloaded intrinsics only"); + assert((Tys.empty() || Intrinsic::isOverloaded(id)) && + "This version of getName is for overloaded intrinsics only"); std::string Result(IntrinsicNameTable[id]); for (Type *Ty : Tys) { Result += "." + getMangledTypeStr(Ty); @@ -849,10 +849,10 @@ enum IIT_Info { IIT_SUBDIVIDE4_ARG = 45, IIT_VEC_OF_BITCASTS_TO_INT = 46, IIT_V128 = 47, - IIT_BF16 = 48, - IIT_STRUCT9 = 49, - IIT_V256 = 50, - IIT_AMX = 51 + IIT_BF16 = 48, + IIT_STRUCT9 = 49, + IIT_V256 = 50, + IIT_AMX = 51 }; static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, @@ -875,9 +875,9 @@ static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, case IIT_MMX: OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0)); return; - case IIT_AMX: - OutputTable.push_back(IITDescriptor::get(IITDescriptor::AMX, 0)); - return; + case IIT_AMX: + OutputTable.push_back(IITDescriptor::get(IITDescriptor::AMX, 0)); + return; case IIT_TOKEN: OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0)); return; @@ -949,10 +949,10 @@ static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, OutputTable.push_back(IITDescriptor::getVector(128, IsScalableVector)); DecodeIITType(NextElt, Infos, Info, OutputTable); return; - case IIT_V256: - OutputTable.push_back(IITDescriptor::getVector(256, IsScalableVector)); - DecodeIITType(NextElt, Infos, Info, OutputTable); - return; + case IIT_V256: + OutputTable.push_back(IITDescriptor::getVector(256, IsScalableVector)); + DecodeIITType(NextElt, Infos, Info, OutputTable); + return; case IIT_V512: OutputTable.push_back(IITDescriptor::getVector(512, IsScalableVector)); DecodeIITType(NextElt, Infos, Info, OutputTable); @@ -1021,7 +1021,7 @@ static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, case IIT_EMPTYSTRUCT: OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0)); return; - case IIT_STRUCT9: ++StructElts; LLVM_FALLTHROUGH; + case IIT_STRUCT9: ++StructElts; LLVM_FALLTHROUGH; case IIT_STRUCT8: ++StructElts; LLVM_FALLTHROUGH; case IIT_STRUCT7: ++StructElts; LLVM_FALLTHROUGH; case IIT_STRUCT6: ++StructElts; LLVM_FALLTHROUGH; @@ -1115,7 +1115,7 @@ static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos, case IITDescriptor::Void: return Type::getVoidTy(Context); case IITDescriptor::VarArg: return Type::getVoidTy(Context); case IITDescriptor::MMX: return Type::getX86_MMXTy(Context); - case IITDescriptor::AMX: return Type::getX86_AMXTy(Context); + case IITDescriptor::AMX: return Type::getX86_AMXTy(Context); case IITDescriptor::Token: return Type::getTokenTy(Context); case IITDescriptor::Metadata: return Type::getMetadataTy(Context); case IITDescriptor::Half: return Type::getHalfTy(Context); @@ -1253,7 +1253,7 @@ Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) { // There can never be multiple globals with the same name of different types, // because intrinsics must be a specific type. return cast<Function>( - M->getOrInsertFunction(Tys.empty() ? getName(id) : getName(id, Tys), + M->getOrInsertFunction(Tys.empty() ? getName(id) : getName(id, Tys), getType(M->getContext(), id, Tys)) .getCallee()); } @@ -1295,7 +1295,7 @@ static bool matchIntrinsicType( case IITDescriptor::Void: return !Ty->isVoidTy(); case IITDescriptor::VarArg: return true; case IITDescriptor::MMX: return !Ty->isX86_MMXTy(); - case IITDescriptor::AMX: return !Ty->isX86_AMXTy(); + case IITDescriptor::AMX: return !Ty->isX86_AMXTy(); case IITDescriptor::Token: return !Ty->isTokenTy(); case IITDescriptor::Metadata: return !Ty->isMetadataTy(); case IITDescriptor::Half: return !Ty->isHalfTy(); @@ -1448,10 +1448,10 @@ static bool matchIntrinsicType( // Verify the overloaded type "matches" the Ref type. // i.e. Ty is a vector with the same width as Ref. // Composed of pointers to the same element type as Ref. - auto *ReferenceType = dyn_cast<VectorType>(ArgTys[RefArgNumber]); - auto *ThisArgVecTy = dyn_cast<VectorType>(Ty); + auto *ReferenceType = dyn_cast<VectorType>(ArgTys[RefArgNumber]); + auto *ThisArgVecTy = dyn_cast<VectorType>(Ty); if (!ThisArgVecTy || !ReferenceType || - (ReferenceType->getElementCount() != ThisArgVecTy->getElementCount())) + (ReferenceType->getElementCount() != ThisArgVecTy->getElementCount())) return true; PointerType *ThisArgEltTy = dyn_cast<PointerType>(ThisArgVecTy->getElementType()); diff --git a/contrib/libs/llvm12/lib/IR/Globals.cpp b/contrib/libs/llvm12/lib/IR/Globals.cpp index c2cbe7dddd..e6571e3914 100644 --- a/contrib/libs/llvm12/lib/IR/Globals.cpp +++ b/contrib/libs/llvm12/lib/IR/Globals.cpp @@ -352,15 +352,15 @@ GlobalVariable::GlobalVariable(Type *Ty, bool constant, LinkageTypes Link, GlobalVariable::GlobalVariable(Module &M, Type *Ty, bool constant, LinkageTypes Link, Constant *InitVal, const Twine &Name, GlobalVariable *Before, - ThreadLocalMode TLMode, - Optional<unsigned> AddressSpace, + ThreadLocalMode TLMode, + Optional<unsigned> AddressSpace, bool isExternallyInitialized) : GlobalObject(Ty, Value::GlobalVariableVal, OperandTraits<GlobalVariable>::op_begin(this), - InitVal != nullptr, Link, Name, - AddressSpace - ? *AddressSpace - : M.getDataLayout().getDefaultGlobalsAddressSpace()), + InitVal != nullptr, Link, Name, + AddressSpace + ? *AddressSpace + : M.getDataLayout().getDefaultGlobalsAddressSpace()), isConstantGlobal(constant), isExternallyInitializedConstant(isExternallyInitialized) { assert(!Ty->isFunctionTy() && PointerType::isValidElementType(Ty) && diff --git a/contrib/libs/llvm12/lib/IR/IRBuilder.cpp b/contrib/libs/llvm12/lib/IR/IRBuilder.cpp index 91ca984b75..26de152afa 100644 --- a/contrib/libs/llvm12/lib/IR/IRBuilder.cpp +++ b/contrib/libs/llvm12/lib/IR/IRBuilder.cpp @@ -72,25 +72,25 @@ Value *IRBuilderBase::getCastedInt8PtrValue(Value *Ptr) { static CallInst *createCallHelper(Function *Callee, ArrayRef<Value *> Ops, IRBuilderBase *Builder, const Twine &Name = "", - Instruction *FMFSource = nullptr, - ArrayRef<OperandBundleDef> OpBundles = {}) { - CallInst *CI = Builder->CreateCall(Callee, Ops, OpBundles, Name); + Instruction *FMFSource = nullptr, + ArrayRef<OperandBundleDef> OpBundles = {}) { + CallInst *CI = Builder->CreateCall(Callee, Ops, OpBundles, Name); if (FMFSource) CI->copyFastMathFlags(FMFSource); return CI; } -Value *IRBuilderBase::CreateVScale(Constant *Scaling, const Twine &Name) { - Module *M = GetInsertBlock()->getParent()->getParent(); - assert(isa<ConstantInt>(Scaling) && "Expected constant integer"); - Function *TheFn = - Intrinsic::getDeclaration(M, Intrinsic::vscale, {Scaling->getType()}); - CallInst *CI = createCallHelper(TheFn, {}, this, Name); - return cast<ConstantInt>(Scaling)->getSExtValue() == 1 - ? CI - : CreateMul(CI, Scaling); -} - +Value *IRBuilderBase::CreateVScale(Constant *Scaling, const Twine &Name) { + Module *M = GetInsertBlock()->getParent()->getParent(); + assert(isa<ConstantInt>(Scaling) && "Expected constant integer"); + Function *TheFn = + Intrinsic::getDeclaration(M, Intrinsic::vscale, {Scaling->getType()}); + CallInst *CI = createCallHelper(TheFn, {}, this, Name); + return cast<ConstantInt>(Scaling)->getSExtValue() == 1 + ? CI + : CreateMul(CI, Scaling); +} + CallInst *IRBuilderBase::CreateMemSet(Value *Ptr, Value *Val, Value *Size, MaybeAlign Align, bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag, @@ -147,21 +147,21 @@ CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemSet( return CI; } -CallInst *IRBuilderBase::CreateMemTransferInst( - Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src, - MaybeAlign SrcAlign, Value *Size, bool isVolatile, MDNode *TBAATag, - MDNode *TBAAStructTag, MDNode *ScopeTag, MDNode *NoAliasTag) { +CallInst *IRBuilderBase::CreateMemTransferInst( + Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src, + MaybeAlign SrcAlign, Value *Size, bool isVolatile, MDNode *TBAATag, + MDNode *TBAAStructTag, MDNode *ScopeTag, MDNode *NoAliasTag) { Dst = getCastedInt8PtrValue(Dst); Src = getCastedInt8PtrValue(Src); Value *Ops[] = {Dst, Src, Size, getInt1(isVolatile)}; Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() }; Module *M = BB->getParent()->getParent(); - Function *TheFn = Intrinsic::getDeclaration(M, IntrID, Tys); + Function *TheFn = Intrinsic::getDeclaration(M, IntrID, Tys); CallInst *CI = createCallHelper(TheFn, Ops, this); - auto* MCI = cast<MemTransferInst>(CI); + auto* MCI = cast<MemTransferInst>(CI); if (DstAlign) MCI->setDestAlignment(*DstAlign); if (SrcAlign) @@ -335,57 +335,57 @@ static CallInst *getReductionIntrinsic(IRBuilderBase *Builder, Intrinsic::ID ID, CallInst *IRBuilderBase::CreateFAddReduce(Value *Acc, Value *Src) { Module *M = GetInsertBlock()->getParent()->getParent(); Value *Ops[] = {Acc, Src}; - auto Decl = Intrinsic::getDeclaration(M, Intrinsic::vector_reduce_fadd, - {Src->getType()}); + auto Decl = Intrinsic::getDeclaration(M, Intrinsic::vector_reduce_fadd, + {Src->getType()}); return createCallHelper(Decl, Ops, this); } CallInst *IRBuilderBase::CreateFMulReduce(Value *Acc, Value *Src) { Module *M = GetInsertBlock()->getParent()->getParent(); Value *Ops[] = {Acc, Src}; - auto Decl = Intrinsic::getDeclaration(M, Intrinsic::vector_reduce_fmul, - {Src->getType()}); + auto Decl = Intrinsic::getDeclaration(M, Intrinsic::vector_reduce_fmul, + {Src->getType()}); return createCallHelper(Decl, Ops, this); } CallInst *IRBuilderBase::CreateAddReduce(Value *Src) { - return getReductionIntrinsic(this, Intrinsic::vector_reduce_add, Src); + return getReductionIntrinsic(this, Intrinsic::vector_reduce_add, Src); } CallInst *IRBuilderBase::CreateMulReduce(Value *Src) { - return getReductionIntrinsic(this, Intrinsic::vector_reduce_mul, Src); + return getReductionIntrinsic(this, Intrinsic::vector_reduce_mul, Src); } CallInst *IRBuilderBase::CreateAndReduce(Value *Src) { - return getReductionIntrinsic(this, Intrinsic::vector_reduce_and, Src); + return getReductionIntrinsic(this, Intrinsic::vector_reduce_and, Src); } CallInst *IRBuilderBase::CreateOrReduce(Value *Src) { - return getReductionIntrinsic(this, Intrinsic::vector_reduce_or, Src); + return getReductionIntrinsic(this, Intrinsic::vector_reduce_or, Src); } CallInst *IRBuilderBase::CreateXorReduce(Value *Src) { - return getReductionIntrinsic(this, Intrinsic::vector_reduce_xor, Src); + return getReductionIntrinsic(this, Intrinsic::vector_reduce_xor, Src); } CallInst *IRBuilderBase::CreateIntMaxReduce(Value *Src, bool IsSigned) { - auto ID = - IsSigned ? Intrinsic::vector_reduce_smax : Intrinsic::vector_reduce_umax; + auto ID = + IsSigned ? Intrinsic::vector_reduce_smax : Intrinsic::vector_reduce_umax; return getReductionIntrinsic(this, ID, Src); } CallInst *IRBuilderBase::CreateIntMinReduce(Value *Src, bool IsSigned) { - auto ID = - IsSigned ? Intrinsic::vector_reduce_smin : Intrinsic::vector_reduce_umin; + auto ID = + IsSigned ? Intrinsic::vector_reduce_smin : Intrinsic::vector_reduce_umin; return getReductionIntrinsic(this, ID, Src); } -CallInst *IRBuilderBase::CreateFPMaxReduce(Value *Src) { - return getReductionIntrinsic(this, Intrinsic::vector_reduce_fmax, Src); +CallInst *IRBuilderBase::CreateFPMaxReduce(Value *Src) { + return getReductionIntrinsic(this, Intrinsic::vector_reduce_fmax, Src); } -CallInst *IRBuilderBase::CreateFPMinReduce(Value *Src) { - return getReductionIntrinsic(this, Intrinsic::vector_reduce_fmin, Src); +CallInst *IRBuilderBase::CreateFPMinReduce(Value *Src) { + return getReductionIntrinsic(this, Intrinsic::vector_reduce_fmin, Src); } CallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) { @@ -440,25 +440,25 @@ CallInst *IRBuilderBase::CreateInvariantStart(Value *Ptr, ConstantInt *Size) { return createCallHelper(TheFn, Ops, this); } -CallInst * -IRBuilderBase::CreateAssumption(Value *Cond, - ArrayRef<OperandBundleDef> OpBundles) { +CallInst * +IRBuilderBase::CreateAssumption(Value *Cond, + ArrayRef<OperandBundleDef> OpBundles) { assert(Cond->getType() == getInt1Ty() && "an assumption condition must be of type i1"); Value *Ops[] = { Cond }; Module *M = BB->getParent()->getParent(); Function *FnAssume = Intrinsic::getDeclaration(M, Intrinsic::assume); - return createCallHelper(FnAssume, Ops, this, "", nullptr, OpBundles); -} - -Instruction *IRBuilderBase::CreateNoAliasScopeDeclaration(Value *Scope) { - Module *M = BB->getModule(); - auto *FnIntrinsic = Intrinsic::getDeclaration( - M, Intrinsic::experimental_noalias_scope_decl, {}); - return createCallHelper(FnIntrinsic, {Scope}, this); + return createCallHelper(FnAssume, Ops, this, "", nullptr, OpBundles); } +Instruction *IRBuilderBase::CreateNoAliasScopeDeclaration(Value *Scope) { + Module *M = BB->getModule(); + auto *FnIntrinsic = Intrinsic::getDeclaration( + M, Intrinsic::experimental_noalias_scope_decl, {}); + return createCallHelper(FnIntrinsic, {Scope}, this); +} + /// Create a call to a Masked Load intrinsic. /// \p Ptr - base pointer for the load /// \p Alignment - alignment of the source location @@ -522,8 +522,8 @@ CallInst *IRBuilderBase::CreateMaskedIntrinsic(Intrinsic::ID Id, CallInst *IRBuilderBase::CreateMaskedGather(Value *Ptrs, Align Alignment, Value *Mask, Value *PassThru, const Twine &Name) { - auto *PtrsTy = cast<FixedVectorType>(Ptrs->getType()); - auto *PtrTy = cast<PointerType>(PtrsTy->getElementType()); + auto *PtrsTy = cast<FixedVectorType>(Ptrs->getType()); + auto *PtrTy = cast<PointerType>(PtrsTy->getElementType()); unsigned NumElts = PtrsTy->getNumElements(); auto *DataTy = FixedVectorType::get(PtrTy->getElementType(), NumElts); @@ -552,8 +552,8 @@ CallInst *IRBuilderBase::CreateMaskedGather(Value *Ptrs, Align Alignment, /// be accessed in memory CallInst *IRBuilderBase::CreateMaskedScatter(Value *Data, Value *Ptrs, Align Alignment, Value *Mask) { - auto *PtrsTy = cast<FixedVectorType>(Ptrs->getType()); - auto *DataTy = cast<FixedVectorType>(Data->getType()); + auto *PtrsTy = cast<FixedVectorType>(Ptrs->getType()); + auto *DataTy = cast<FixedVectorType>(Data->getType()); unsigned NumElts = PtrsTy->getNumElements(); #ifndef NDEBUG @@ -585,7 +585,7 @@ getStatepointArgs(IRBuilderBase &B, uint64_t ID, uint32_t NumPatchBytes, Args.push_back(ActualCallee); Args.push_back(B.getInt32(CallArgs.size())); Args.push_back(B.getInt32(Flags)); - llvm::append_range(Args, CallArgs); + llvm::append_range(Args, CallArgs); // GC Transition and Deopt args are now always handled via operand bundle. // They will be removed from the signature of gc.statepoint shortly. Args.push_back(B.getInt32(0)); @@ -602,17 +602,17 @@ getStatepointBundles(Optional<ArrayRef<T1>> TransitionArgs, std::vector<OperandBundleDef> Rval; if (DeoptArgs) { SmallVector<Value*, 16> DeoptValues; - llvm::append_range(DeoptValues, *DeoptArgs); + llvm::append_range(DeoptValues, *DeoptArgs); Rval.emplace_back("deopt", DeoptValues); } if (TransitionArgs) { SmallVector<Value*, 16> TransitionValues; - llvm::append_range(TransitionValues, *TransitionArgs); + llvm::append_range(TransitionValues, *TransitionArgs); Rval.emplace_back("gc-transition", TransitionValues); } if (GCArgs.size()) { SmallVector<Value*, 16> LiveValues; - llvm::append_range(LiveValues, GCArgs); + llvm::append_range(LiveValues, GCArgs); Rval.emplace_back("gc-live", LiveValues); } return Rval; @@ -658,10 +658,10 @@ CallInst *IRBuilderBase::CreateGCStatepointCall( CallInst *IRBuilderBase::CreateGCStatepointCall( uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee, uint32_t Flags, - ArrayRef<Value *> CallArgs, Optional<ArrayRef<Use>> TransitionArgs, + ArrayRef<Value *> CallArgs, Optional<ArrayRef<Use>> TransitionArgs, Optional<ArrayRef<Use>> DeoptArgs, ArrayRef<Value *> GCArgs, const Twine &Name) { - return CreateGCStatepointCallCommon<Value *, Use, Use, Value *>( + return CreateGCStatepointCallCommon<Value *, Use, Use, Value *>( this, ID, NumPatchBytes, ActualCallee, Flags, CallArgs, TransitionArgs, DeoptArgs, GCArgs, Name); } @@ -716,9 +716,9 @@ InvokeInst *IRBuilderBase::CreateGCStatepointInvoke( InvokeInst *IRBuilderBase::CreateGCStatepointInvoke( uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee, BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags, - ArrayRef<Value *> InvokeArgs, Optional<ArrayRef<Use>> TransitionArgs, + ArrayRef<Value *> InvokeArgs, Optional<ArrayRef<Use>> TransitionArgs, Optional<ArrayRef<Use>> DeoptArgs, ArrayRef<Value *> GCArgs, const Twine &Name) { - return CreateGCStatepointInvokeCommon<Value *, Use, Use, Value *>( + return CreateGCStatepointInvokeCommon<Value *, Use, Use, Value *>( this, ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest, Flags, InvokeArgs, TransitionArgs, DeoptArgs, GCArgs, Name); } @@ -995,24 +995,24 @@ Value *IRBuilderBase::CreateStripInvariantGroup(Value *Ptr) { Value *IRBuilderBase::CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name) { - auto EC = ElementCount::getFixed(NumElts); - return CreateVectorSplat(EC, V, Name); -} - -Value *IRBuilderBase::CreateVectorSplat(ElementCount EC, Value *V, - const Twine &Name) { - assert(EC.isNonZero() && "Cannot splat to an empty vector!"); - - // First insert it into a poison vector so we can shuffle it. + auto EC = ElementCount::getFixed(NumElts); + return CreateVectorSplat(EC, V, Name); +} + +Value *IRBuilderBase::CreateVectorSplat(ElementCount EC, Value *V, + const Twine &Name) { + assert(EC.isNonZero() && "Cannot splat to an empty vector!"); + + // First insert it into a poison vector so we can shuffle it. Type *I32Ty = getInt32Ty(); - Value *Poison = PoisonValue::get(VectorType::get(V->getType(), EC)); - V = CreateInsertElement(Poison, V, ConstantInt::get(I32Ty, 0), + Value *Poison = PoisonValue::get(VectorType::get(V->getType(), EC)); + V = CreateInsertElement(Poison, V, ConstantInt::get(I32Ty, 0), Name + ".splatinsert"); // Shuffle the value across the desired number of elements. - SmallVector<int, 16> Zeros; - Zeros.resize(EC.getKnownMinValue()); - return CreateShuffleVector(V, Zeros, Name + ".splat"); + SmallVector<int, 16> Zeros; + Zeros.resize(EC.getKnownMinValue()); + return CreateShuffleVector(V, Zeros, Name + ".splat"); } Value *IRBuilderBase::CreateExtractInteger( @@ -1047,7 +1047,7 @@ Value *IRBuilderBase::CreatePreserveArrayAccessIndex( Value *LastIndexV = getInt32(LastIndex); Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0); - SmallVector<Value *, 4> IdxList(Dimension, Zero); + SmallVector<Value *, 4> IdxList(Dimension, Zero); IdxList.push_back(LastIndexV); Type *ResultType = @@ -1110,37 +1110,37 @@ Value *IRBuilderBase::CreatePreserveStructAccessIndex( return Fn; } -CallInst *IRBuilderBase::CreateAlignmentAssumptionHelper(const DataLayout &DL, - Value *PtrValue, - Value *AlignValue, - Value *OffsetValue) { - SmallVector<Value *, 4> Vals({PtrValue, AlignValue}); - if (OffsetValue) - Vals.push_back(OffsetValue); - OperandBundleDefT<Value *> AlignOpB("align", Vals); - return CreateAssumption(ConstantInt::getTrue(getContext()), {AlignOpB}); +CallInst *IRBuilderBase::CreateAlignmentAssumptionHelper(const DataLayout &DL, + Value *PtrValue, + Value *AlignValue, + Value *OffsetValue) { + SmallVector<Value *, 4> Vals({PtrValue, AlignValue}); + if (OffsetValue) + Vals.push_back(OffsetValue); + OperandBundleDefT<Value *> AlignOpB("align", Vals); + return CreateAssumption(ConstantInt::getTrue(getContext()), {AlignOpB}); } -CallInst *IRBuilderBase::CreateAlignmentAssumption(const DataLayout &DL, - Value *PtrValue, - unsigned Alignment, - Value *OffsetValue) { +CallInst *IRBuilderBase::CreateAlignmentAssumption(const DataLayout &DL, + Value *PtrValue, + unsigned Alignment, + Value *OffsetValue) { assert(isa<PointerType>(PtrValue->getType()) && "trying to create an alignment assumption on a non-pointer?"); assert(Alignment != 0 && "Invalid Alignment"); auto *PtrTy = cast<PointerType>(PtrValue->getType()); Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace()); - Value *AlignValue = ConstantInt::get(IntPtrTy, Alignment); - return CreateAlignmentAssumptionHelper(DL, PtrValue, AlignValue, OffsetValue); + Value *AlignValue = ConstantInt::get(IntPtrTy, Alignment); + return CreateAlignmentAssumptionHelper(DL, PtrValue, AlignValue, OffsetValue); } -CallInst *IRBuilderBase::CreateAlignmentAssumption(const DataLayout &DL, - Value *PtrValue, - Value *Alignment, - Value *OffsetValue) { +CallInst *IRBuilderBase::CreateAlignmentAssumption(const DataLayout &DL, + Value *PtrValue, + Value *Alignment, + Value *OffsetValue) { assert(isa<PointerType>(PtrValue->getType()) && "trying to create an alignment assumption on a non-pointer?"); - return CreateAlignmentAssumptionHelper(DL, PtrValue, Alignment, OffsetValue); + return CreateAlignmentAssumptionHelper(DL, PtrValue, Alignment, OffsetValue); } IRBuilderDefaultInserter::~IRBuilderDefaultInserter() {} diff --git a/contrib/libs/llvm12/lib/IR/IRPrintingPasses.cpp b/contrib/libs/llvm12/lib/IR/IRPrintingPasses.cpp index 8d6fe1eb61..e9caec326c 100644 --- a/contrib/libs/llvm12/lib/IR/IRPrintingPasses.cpp +++ b/contrib/libs/llvm12/lib/IR/IRPrintingPasses.cpp @@ -11,15 +11,15 @@ //===----------------------------------------------------------------------===// #include "llvm/IR/IRPrintingPasses.h" -#include "llvm/ADT/StringRef.h" +#include "llvm/ADT/StringRef.h" #include "llvm/IR/Function.h" #include "llvm/IR/Module.h" -#include "llvm/IR/PrintPasses.h" +#include "llvm/IR/PrintPasses.h" #include "llvm/InitializePasses.h" #include "llvm/Pass.h" #include "llvm/Support/Debug.h" #include "llvm/Support/raw_ostream.h" - + using namespace llvm; PrintModulePass::PrintModulePass() : OS(dbgs()) {} diff --git a/contrib/libs/llvm12/lib/IR/Instruction.cpp b/contrib/libs/llvm12/lib/IR/Instruction.cpp index 8e52dd3ddc..b34f097498 100644 --- a/contrib/libs/llvm12/lib/IR/Instruction.cpp +++ b/contrib/libs/llvm12/lib/IR/Instruction.cpp @@ -485,7 +485,7 @@ bool Instruction::isIdenticalToWhenDefined(const Instruction *I) const { if (!std::equal(op_begin(), op_end(), I->op_begin())) return false; - // WARNING: this logic must be kept in sync with EliminateDuplicatePHINodes()! + // WARNING: this logic must be kept in sync with EliminateDuplicatePHINodes()! if (const PHINode *thisPHI = dyn_cast<PHINode>(this)) { const PHINode *otherPHI = cast<PHINode>(I); return std::equal(thisPHI->block_begin(), thisPHI->block_end(), @@ -633,16 +633,16 @@ bool Instruction::isSafeToRemove() const { !this->isTerminator(); } -bool Instruction::willReturn() const { - if (const auto *CB = dyn_cast<CallBase>(this)) - // FIXME: Temporarily assume that all side-effect free intrinsics will - // return. Remove this workaround once all intrinsics are appropriately - // annotated. - return CB->hasFnAttr(Attribute::WillReturn) || - (isa<IntrinsicInst>(CB) && CB->onlyReadsMemory()); - return true; -} - +bool Instruction::willReturn() const { + if (const auto *CB = dyn_cast<CallBase>(this)) + // FIXME: Temporarily assume that all side-effect free intrinsics will + // return. Remove this workaround once all intrinsics are appropriately + // annotated. + return CB->hasFnAttr(Attribute::WillReturn) || + (isa<IntrinsicInst>(CB) && CB->onlyReadsMemory()); + return true; +} + bool Instruction::isLifetimeStartOrEnd() const { auto II = dyn_cast<IntrinsicInst>(this); if (!II) @@ -651,22 +651,22 @@ bool Instruction::isLifetimeStartOrEnd() const { return ID == Intrinsic::lifetime_start || ID == Intrinsic::lifetime_end; } -bool Instruction::isDebugOrPseudoInst() const { - return isa<DbgInfoIntrinsic>(this) || isa<PseudoProbeInst>(this); -} - -const Instruction * -Instruction::getNextNonDebugInstruction(bool SkipPseudoOp) const { +bool Instruction::isDebugOrPseudoInst() const { + return isa<DbgInfoIntrinsic>(this) || isa<PseudoProbeInst>(this); +} + +const Instruction * +Instruction::getNextNonDebugInstruction(bool SkipPseudoOp) const { for (const Instruction *I = getNextNode(); I; I = I->getNextNode()) - if (!isa<DbgInfoIntrinsic>(I) && !(SkipPseudoOp && isa<PseudoProbeInst>(I))) + if (!isa<DbgInfoIntrinsic>(I) && !(SkipPseudoOp && isa<PseudoProbeInst>(I))) return I; return nullptr; } -const Instruction * -Instruction::getPrevNonDebugInstruction(bool SkipPseudoOp) const { +const Instruction * +Instruction::getPrevNonDebugInstruction(bool SkipPseudoOp) const { for (const Instruction *I = getPrevNode(); I; I = I->getPrevNode()) - if (!isa<DbgInfoIntrinsic>(I) && !(SkipPseudoOp && isa<PseudoProbeInst>(I))) + if (!isa<DbgInfoIntrinsic>(I) && !(SkipPseudoOp && isa<PseudoProbeInst>(I))) return I; return nullptr; } @@ -686,13 +686,13 @@ bool Instruction::isAssociative() const { } } -bool Instruction::isCommutative() const { - if (auto *II = dyn_cast<IntrinsicInst>(this)) - return II->isCommutative(); - // TODO: Should allow icmp/fcmp? - return isCommutative(getOpcode()); -} - +bool Instruction::isCommutative() const { + if (auto *II = dyn_cast<IntrinsicInst>(this)) + return II->isCommutative(); + // TODO: Should allow icmp/fcmp? + return isCommutative(getOpcode()); +} + unsigned Instruction::getNumSuccessors() const { switch (getOpcode()) { #define HANDLE_TERM_INST(N, OPC, CLASS) \ diff --git a/contrib/libs/llvm12/lib/IR/Instructions.cpp b/contrib/libs/llvm12/lib/IR/Instructions.cpp index 36db1098a1..429fe390f2 100644 --- a/contrib/libs/llvm12/lib/IR/Instructions.cpp +++ b/contrib/libs/llvm12/lib/IR/Instructions.cpp @@ -49,14 +49,14 @@ using namespace llvm; // AllocaInst Class //===----------------------------------------------------------------------===// -Optional<TypeSize> +Optional<TypeSize> AllocaInst::getAllocationSizeInBits(const DataLayout &DL) const { - TypeSize Size = DL.getTypeAllocSizeInBits(getAllocatedType()); + TypeSize Size = DL.getTypeAllocSizeInBits(getAllocatedType()); if (isArrayAllocation()) { auto *C = dyn_cast<ConstantInt>(getArraySize()); if (!C) return None; - assert(!Size.isScalable() && "Array elements cannot have a scalable size"); + assert(!Size.isScalable() && "Array elements cannot have a scalable size"); Size *= C->getZExtValue(); } return Size; @@ -400,7 +400,7 @@ CallBase::BundleOpInfo &CallBase::getBundleOpInfoForOperand(unsigned OpIdx) { bundle_op_iterator Begin = bundle_op_info_begin(); bundle_op_iterator End = bundle_op_info_end(); - bundle_op_iterator Current = Begin; + bundle_op_iterator Current = Begin; while (Begin != End) { unsigned ScaledOperandPerBundle = @@ -506,18 +506,18 @@ CallInst *CallInst::Create(CallInst *CI, ArrayRef<OperandBundleDef> OpB, return NewCI; } -CallInst *CallInst::CreateWithReplacedBundle(CallInst *CI, OperandBundleDef OpB, - Instruction *InsertPt) { - SmallVector<OperandBundleDef, 2> OpDefs; - for (unsigned i = 0, e = CI->getNumOperandBundles(); i < e; ++i) { - auto ChildOB = CI->getOperandBundleAt(i); - if (ChildOB.getTagName() != OpB.getTag()) - OpDefs.emplace_back(ChildOB); - } - OpDefs.emplace_back(OpB); - return CallInst::Create(CI, OpDefs, InsertPt); -} - +CallInst *CallInst::CreateWithReplacedBundle(CallInst *CI, OperandBundleDef OpB, + Instruction *InsertPt) { + SmallVector<OperandBundleDef, 2> OpDefs; + for (unsigned i = 0, e = CI->getNumOperandBundles(); i < e; ++i) { + auto ChildOB = CI->getOperandBundleAt(i); + if (ChildOB.getTagName() != OpB.getTag()) + OpDefs.emplace_back(ChildOB); + } + OpDefs.emplace_back(OpB); + return CallInst::Create(CI, OpDefs, InsertPt); +} + // Update profile weight for call instruction by scaling it using the ratio // of S/T. The meaning of "branch_weights" meta data for call instruction is // transfered to represent call count. @@ -551,9 +551,9 @@ void CallInst::updateProfWeight(uint64_t S, uint64_t T) { ->getValue() .getZExtValue()); Val *= APS; - Vals.push_back(MDB.createConstant( - ConstantInt::get(Type::getInt32Ty(getContext()), - Val.udiv(APT).getLimitedValue(UINT32_MAX)))); + Vals.push_back(MDB.createConstant( + ConstantInt::get(Type::getInt32Ty(getContext()), + Val.udiv(APT).getLimitedValue(UINT32_MAX)))); } else if (ProfDataName->getString().equals("VP")) for (unsigned i = 1; i < ProfileData->getNumOperands(); i += 2) { // The first value is the key of the value profile, which will not change. @@ -830,18 +830,18 @@ InvokeInst *InvokeInst::Create(InvokeInst *II, ArrayRef<OperandBundleDef> OpB, return NewII; } -InvokeInst *InvokeInst::CreateWithReplacedBundle(InvokeInst *II, - OperandBundleDef OpB, - Instruction *InsertPt) { - SmallVector<OperandBundleDef, 2> OpDefs; - for (unsigned i = 0, e = II->getNumOperandBundles(); i < e; ++i) { - auto ChildOB = II->getOperandBundleAt(i); - if (ChildOB.getTagName() != OpB.getTag()) - OpDefs.emplace_back(ChildOB); - } - OpDefs.emplace_back(OpB); - return InvokeInst::Create(II, OpDefs, InsertPt); -} +InvokeInst *InvokeInst::CreateWithReplacedBundle(InvokeInst *II, + OperandBundleDef OpB, + Instruction *InsertPt) { + SmallVector<OperandBundleDef, 2> OpDefs; + for (unsigned i = 0, e = II->getNumOperandBundles(); i < e; ++i) { + auto ChildOB = II->getOperandBundleAt(i); + if (ChildOB.getTagName() != OpB.getTag()) + OpDefs.emplace_back(ChildOB); + } + OpDefs.emplace_back(OpB); + return InvokeInst::Create(II, OpDefs, InsertPt); +} LandingPadInst *InvokeInst::getLandingPadInst() const { return cast<LandingPadInst>(getUnwindDest()->getFirstNonPHI()); @@ -1935,7 +1935,7 @@ ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask, } void ShuffleVectorInst::commute() { - int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); + int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); int NumMaskElts = ShuffleMask.size(); SmallVector<int, 16> NewMask(NumMaskElts); for (int i = 0; i != NumMaskElts; ++i) { @@ -1959,8 +1959,8 @@ bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2, return false; // Make sure the mask elements make sense. - int V1Size = - cast<VectorType>(V1->getType())->getElementCount().getKnownMinValue(); + int V1Size = + cast<VectorType>(V1->getType())->getElementCount().getKnownMinValue(); for (int Elem : Mask) if (Elem != UndefMaskElem && Elem >= V1Size * 2) return false; @@ -1990,7 +1990,7 @@ bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2, return true; if (const auto *MV = dyn_cast<ConstantVector>(Mask)) { - unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements(); + unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements(); for (Value *Op : MV->operands()) { if (auto *CI = dyn_cast<ConstantInt>(Op)) { if (CI->uge(V1Size*2)) @@ -2003,9 +2003,9 @@ bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2, } if (const auto *CDS = dyn_cast<ConstantDataSequential>(Mask)) { - unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements(); - for (unsigned i = 0, e = cast<FixedVectorType>(MaskTy)->getNumElements(); - i != e; ++i) + unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements(); + for (unsigned i = 0, e = cast<FixedVectorType>(MaskTy)->getNumElements(); + i != e; ++i) if (CDS->getElementAsInteger(i) >= V1Size*2) return false; return true; @@ -2016,26 +2016,26 @@ bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2, void ShuffleVectorInst::getShuffleMask(const Constant *Mask, SmallVectorImpl<int> &Result) { - ElementCount EC = cast<VectorType>(Mask->getType())->getElementCount(); - + ElementCount EC = cast<VectorType>(Mask->getType())->getElementCount(); + if (isa<ConstantAggregateZero>(Mask)) { - Result.resize(EC.getKnownMinValue(), 0); - return; - } - - Result.reserve(EC.getKnownMinValue()); - - if (EC.isScalable()) { - assert((isa<ConstantAggregateZero>(Mask) || isa<UndefValue>(Mask)) && - "Scalable vector shuffle mask must be undef or zeroinitializer"); - int MaskVal = isa<UndefValue>(Mask) ? -1 : 0; - for (unsigned I = 0; I < EC.getKnownMinValue(); ++I) - Result.emplace_back(MaskVal); + Result.resize(EC.getKnownMinValue(), 0); return; } - - unsigned NumElts = EC.getKnownMinValue(); - + + Result.reserve(EC.getKnownMinValue()); + + if (EC.isScalable()) { + assert((isa<ConstantAggregateZero>(Mask) || isa<UndefValue>(Mask)) && + "Scalable vector shuffle mask must be undef or zeroinitializer"); + int MaskVal = isa<UndefValue>(Mask) ? -1 : 0; + for (unsigned I = 0; I < EC.getKnownMinValue(); ++I) + Result.emplace_back(MaskVal); + return; + } + + unsigned NumElts = EC.getKnownMinValue(); + if (auto *CDS = dyn_cast<ConstantDataSequential>(Mask)) { for (unsigned i = 0; i != NumElts; ++i) Result.push_back(CDS->getElementAsInteger(i)); @@ -2217,14 +2217,14 @@ bool ShuffleVectorInst::isExtractSubvectorMask(ArrayRef<int> Mask, bool ShuffleVectorInst::isIdentityWithPadding() const { if (isa<UndefValue>(Op<2>())) return false; - - // FIXME: Not currently possible to express a shuffle mask for a scalable - // vector for this case. - if (isa<ScalableVectorType>(getType())) - return false; - - int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); - int NumMaskElts = cast<FixedVectorType>(getType())->getNumElements(); + + // FIXME: Not currently possible to express a shuffle mask for a scalable + // vector for this case. + if (isa<ScalableVectorType>(getType())) + return false; + + int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); + int NumMaskElts = cast<FixedVectorType>(getType())->getNumElements(); if (NumMaskElts <= NumOpElts) return false; @@ -2246,7 +2246,7 @@ bool ShuffleVectorInst::isIdentityWithExtract() const { return false; // FIXME: Not currently possible to express a shuffle mask for a scalable - // vector for this case. + // vector for this case. if (isa<ScalableVectorType>(getType())) return false; @@ -2264,13 +2264,13 @@ bool ShuffleVectorInst::isConcat() const { isa<UndefValue>(Op<2>())) return false; - // FIXME: Not currently possible to express a shuffle mask for a scalable - // vector for this case. - if (isa<ScalableVectorType>(getType())) - return false; - - int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); - int NumMaskElts = cast<FixedVectorType>(getType())->getNumElements(); + // FIXME: Not currently possible to express a shuffle mask for a scalable + // vector for this case. + if (isa<ScalableVectorType>(getType())) + return false; + + int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); + int NumMaskElts = cast<FixedVectorType>(getType())->getNumElements(); if (NumMaskElts != NumOpElts * 2) return false; @@ -2671,7 +2671,7 @@ bool CastInst::isNoopCast(Instruction::CastOps Opcode, Type *SrcTy, Type *DestTy, const DataLayout &DL) { - assert(castIsValid(Opcode, SrcTy, DestTy) && "method precondition"); + assert(castIsValid(Opcode, SrcTy, DestTy) && "method precondition"); switch (Opcode) { default: llvm_unreachable("Invalid CastOp"); case Instruction::Trunc: @@ -3026,8 +3026,8 @@ CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, "Invalid cast"); assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast"); assert((!Ty->isVectorTy() || - cast<VectorType>(Ty)->getElementCount() == - cast<VectorType>(S->getType())->getElementCount()) && + cast<VectorType>(Ty)->getElementCount() == + cast<VectorType>(S->getType())->getElementCount()) && "Invalid cast"); if (Ty->isIntOrIntVectorTy()) @@ -3045,8 +3045,8 @@ CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, "Invalid cast"); assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast"); assert((!Ty->isVectorTy() || - cast<VectorType>(Ty)->getElementCount() == - cast<VectorType>(S->getType())->getElementCount()) && + cast<VectorType>(Ty)->getElementCount() == + cast<VectorType>(S->getType())->getElementCount()) && "Invalid cast"); if (Ty->isIntOrIntVectorTy()) @@ -3221,7 +3221,7 @@ CastInst::getCastOpcode( // FIXME: Check address space sizes here if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy)) - if (SrcVecTy->getElementCount() == DestVecTy->getElementCount()) { + if (SrcVecTy->getElementCount() == DestVecTy->getElementCount()) { // An element by element cast. Find the appropriate opcode based on the // element types. SrcTy = SrcVecTy->getElementType(); @@ -3311,7 +3311,7 @@ CastInst::getCastOpcode( /// it in one place and to eliminate the redundant code for getting the sizes /// of the types involved. bool -CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) { +CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) { if (!SrcTy->isFirstClassType() || !DstTy->isFirstClassType() || SrcTy->isAggregateType() || DstTy->isAggregateType()) return false; @@ -3327,9 +3327,9 @@ CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) { // scalar types means that checking that vector lengths match also checks that // scalars are not being converted to vectors or vectors to scalars). ElementCount SrcEC = SrcIsVec ? cast<VectorType>(SrcTy)->getElementCount() - : ElementCount::getFixed(0); + : ElementCount::getFixed(0); ElementCount DstEC = DstIsVec ? cast<VectorType>(DstTy)->getElementCount() - : ElementCount::getFixed(0); + : ElementCount::getFixed(0); // Switch on the opcode provided switch (op) { @@ -3387,9 +3387,9 @@ CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) { if (SrcIsVec && DstIsVec) return SrcEC == DstEC; if (SrcIsVec) - return SrcEC == ElementCount::getFixed(1); + return SrcEC == ElementCount::getFixed(1); if (DstIsVec) - return DstEC == ElementCount::getFixed(1); + return DstEC == ElementCount::getFixed(1); return true; } @@ -3640,12 +3640,12 @@ bool CmpInst::isCommutative() const { return cast<FCmpInst>(this)->isCommutative(); } -bool CmpInst::isEquality(Predicate P) { - if (ICmpInst::isIntPredicate(P)) - return ICmpInst::isEquality(P); - if (FCmpInst::isFPPredicate(P)) - return FCmpInst::isEquality(P); - llvm_unreachable("Unsupported predicate kind"); +bool CmpInst::isEquality(Predicate P) { + if (ICmpInst::isIntPredicate(P)) + return ICmpInst::isEquality(P); + if (FCmpInst::isFPPredicate(P)) + return FCmpInst::isEquality(P); + llvm_unreachable("Unsupported predicate kind"); } CmpInst::Predicate CmpInst::getInversePredicate(Predicate pred) { @@ -3769,97 +3769,97 @@ CmpInst::Predicate CmpInst::getSwappedPredicate(Predicate pred) { } } -bool CmpInst::isNonStrictPredicate(Predicate pred) { - switch (pred) { - case ICMP_SGE: - case ICMP_SLE: - case ICMP_UGE: - case ICMP_ULE: - case FCMP_OGE: - case FCMP_OLE: - case FCMP_UGE: - case FCMP_ULE: - return true; - default: - return false; - } -} - -bool CmpInst::isStrictPredicate(Predicate pred) { - switch (pred) { - case ICMP_SGT: - case ICMP_SLT: - case ICMP_UGT: - case ICMP_ULT: - case FCMP_OGT: - case FCMP_OLT: - case FCMP_UGT: - case FCMP_ULT: - return true; - default: - return false; - } -} - -CmpInst::Predicate CmpInst::getStrictPredicate(Predicate pred) { - switch (pred) { - case ICMP_SGE: - return ICMP_SGT; - case ICMP_SLE: - return ICMP_SLT; - case ICMP_UGE: - return ICMP_UGT; - case ICMP_ULE: - return ICMP_ULT; - case FCMP_OGE: - return FCMP_OGT; - case FCMP_OLE: - return FCMP_OLT; - case FCMP_UGE: - return FCMP_UGT; - case FCMP_ULE: - return FCMP_ULT; - default: - return pred; - } -} - +bool CmpInst::isNonStrictPredicate(Predicate pred) { + switch (pred) { + case ICMP_SGE: + case ICMP_SLE: + case ICMP_UGE: + case ICMP_ULE: + case FCMP_OGE: + case FCMP_OLE: + case FCMP_UGE: + case FCMP_ULE: + return true; + default: + return false; + } +} + +bool CmpInst::isStrictPredicate(Predicate pred) { + switch (pred) { + case ICMP_SGT: + case ICMP_SLT: + case ICMP_UGT: + case ICMP_ULT: + case FCMP_OGT: + case FCMP_OLT: + case FCMP_UGT: + case FCMP_ULT: + return true; + default: + return false; + } +} + +CmpInst::Predicate CmpInst::getStrictPredicate(Predicate pred) { + switch (pred) { + case ICMP_SGE: + return ICMP_SGT; + case ICMP_SLE: + return ICMP_SLT; + case ICMP_UGE: + return ICMP_UGT; + case ICMP_ULE: + return ICMP_ULT; + case FCMP_OGE: + return FCMP_OGT; + case FCMP_OLE: + return FCMP_OLT; + case FCMP_UGE: + return FCMP_UGT; + case FCMP_ULE: + return FCMP_ULT; + default: + return pred; + } +} + CmpInst::Predicate CmpInst::getNonStrictPredicate(Predicate pred) { switch (pred) { - case ICMP_SGT: - return ICMP_SGE; - case ICMP_SLT: - return ICMP_SLE; - case ICMP_UGT: - return ICMP_UGE; - case ICMP_ULT: - return ICMP_ULE; - case FCMP_OGT: - return FCMP_OGE; - case FCMP_OLT: - return FCMP_OLE; - case FCMP_UGT: - return FCMP_UGE; - case FCMP_ULT: - return FCMP_ULE; - default: - return pred; + case ICMP_SGT: + return ICMP_SGE; + case ICMP_SLT: + return ICMP_SLE; + case ICMP_UGT: + return ICMP_UGE; + case ICMP_ULT: + return ICMP_ULE; + case FCMP_OGT: + return FCMP_OGE; + case FCMP_OLT: + return FCMP_OLE; + case FCMP_UGT: + return FCMP_UGE; + case FCMP_ULT: + return FCMP_ULE; + default: + return pred; } } -CmpInst::Predicate CmpInst::getFlippedStrictnessPredicate(Predicate pred) { - assert(CmpInst::isRelational(pred) && "Call only with relational predicate!"); - - if (isStrictPredicate(pred)) - return getNonStrictPredicate(pred); - if (isNonStrictPredicate(pred)) - return getStrictPredicate(pred); - - llvm_unreachable("Unknown predicate!"); -} - +CmpInst::Predicate CmpInst::getFlippedStrictnessPredicate(Predicate pred) { + assert(CmpInst::isRelational(pred) && "Call only with relational predicate!"); + + if (isStrictPredicate(pred)) + return getNonStrictPredicate(pred); + if (isNonStrictPredicate(pred)) + return getStrictPredicate(pred); + + llvm_unreachable("Unknown predicate!"); +} + CmpInst::Predicate CmpInst::getSignedPredicate(Predicate pred) { - assert(CmpInst::isUnsigned(pred) && "Call only with unsigned predicates!"); + assert(CmpInst::isUnsigned(pred) && "Call only with unsigned predicates!"); switch (pred) { default: @@ -3875,23 +3875,23 @@ CmpInst::Predicate CmpInst::getSignedPredicate(Predicate pred) { } } -CmpInst::Predicate CmpInst::getUnsignedPredicate(Predicate pred) { - assert(CmpInst::isSigned(pred) && "Call only with signed predicates!"); - - switch (pred) { - default: - llvm_unreachable("Unknown predicate!"); - case CmpInst::ICMP_SLT: - return CmpInst::ICMP_ULT; - case CmpInst::ICMP_SLE: - return CmpInst::ICMP_ULE; - case CmpInst::ICMP_SGT: - return CmpInst::ICMP_UGT; - case CmpInst::ICMP_SGE: - return CmpInst::ICMP_UGE; - } -} - +CmpInst::Predicate CmpInst::getUnsignedPredicate(Predicate pred) { + assert(CmpInst::isSigned(pred) && "Call only with signed predicates!"); + + switch (pred) { + default: + llvm_unreachable("Unknown predicate!"); + case CmpInst::ICMP_SLT: + return CmpInst::ICMP_ULT; + case CmpInst::ICMP_SLE: + return CmpInst::ICMP_ULE; + case CmpInst::ICMP_SGT: + return CmpInst::ICMP_UGT; + case CmpInst::ICMP_SGE: + return CmpInst::ICMP_UGE; + } +} + bool CmpInst::isUnsigned(Predicate predicate) { switch (predicate) { default: return false; @@ -3908,18 +3908,18 @@ bool CmpInst::isSigned(Predicate predicate) { } } -CmpInst::Predicate CmpInst::getFlippedSignednessPredicate(Predicate pred) { - assert(CmpInst::isRelational(pred) && - "Call only with non-equality predicates!"); - - if (isSigned(pred)) - return getUnsignedPredicate(pred); - if (isUnsigned(pred)) - return getSignedPredicate(pred); - - llvm_unreachable("Unknown predicate!"); -} - +CmpInst::Predicate CmpInst::getFlippedSignednessPredicate(Predicate pred) { + assert(CmpInst::isRelational(pred) && + "Call only with non-equality predicates!"); + + if (isSigned(pred)) + return getUnsignedPredicate(pred); + if (isUnsigned(pred)) + return getSignedPredicate(pred); + + llvm_unreachable("Unknown predicate!"); +} + bool CmpInst::isOrdered(Predicate predicate) { switch (predicate) { default: return false; diff --git a/contrib/libs/llvm12/lib/IR/IntrinsicInst.cpp b/contrib/libs/llvm12/lib/IR/IntrinsicInst.cpp index 3d1ea28535..7b35a7b6d8 100644 --- a/contrib/libs/llvm12/lib/IR/IntrinsicInst.cpp +++ b/contrib/libs/llvm12/lib/IR/IntrinsicInst.cpp @@ -208,7 +208,7 @@ Optional<int> VPIntrinsic::GetMaskParamPos(Intrinsic::ID IntrinsicID) { default: return None; -#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \ +#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \ case Intrinsic::VPID: \ return MASKPOS; #include "llvm/IR/VPIntrinsics.def" @@ -220,7 +220,7 @@ Optional<int> VPIntrinsic::GetVectorLengthParamPos(Intrinsic::ID IntrinsicID) { default: return None; -#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \ +#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \ case Intrinsic::VPID: \ return VLENPOS; #include "llvm/IR/VPIntrinsics.def" @@ -232,7 +232,7 @@ bool VPIntrinsic::IsVPIntrinsic(Intrinsic::ID ID) { default: return false; -#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \ +#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \ case Intrinsic::VPID: \ break; #include "llvm/IR/VPIntrinsics.def" @@ -242,26 +242,26 @@ bool VPIntrinsic::IsVPIntrinsic(Intrinsic::ID ID) { // Equivalent non-predicated opcode unsigned VPIntrinsic::GetFunctionalOpcodeForVP(Intrinsic::ID ID) { - unsigned FunctionalOC = Instruction::Call; + unsigned FunctionalOC = Instruction::Call; switch (ID) { default: - break; -#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID: -#define HANDLE_VP_TO_OPC(OPC) FunctionalOC = Instruction::OPC; -#define END_REGISTER_VP_INTRINSIC(...) break; + break; +#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID: +#define HANDLE_VP_TO_OPC(OPC) FunctionalOC = Instruction::OPC; +#define END_REGISTER_VP_INTRINSIC(...) break; #include "llvm/IR/VPIntrinsics.def" } - - return FunctionalOC; + + return FunctionalOC; } -Intrinsic::ID VPIntrinsic::GetForOpcode(unsigned IROPC) { - switch (IROPC) { +Intrinsic::ID VPIntrinsic::GetForOpcode(unsigned IROPC) { + switch (IROPC) { default: return Intrinsic::not_intrinsic; -#define HANDLE_VP_TO_OPC(OPC) case Instruction::OPC: -#define END_REGISTER_VP_INTRINSIC(VPID) return Intrinsic::VPID; +#define HANDLE_VP_TO_OPC(OPC) case Instruction::OPC: +#define END_REGISTER_VP_INTRINSIC(VPID) return Intrinsic::VPID; #include "llvm/IR/VPIntrinsics.def" } } @@ -281,8 +281,8 @@ bool VPIntrinsic::canIgnoreVectorLengthParam() const { // the operation. This function returns true when this is detected statically // in the IR. - // Check whether "W == vscale * EC.getKnownMinValue()" - if (EC.isScalable()) { + // Check whether "W == vscale * EC.getKnownMinValue()" + if (EC.isScalable()) { // Undig the DL auto ParMod = this->getModule(); if (!ParMod) @@ -292,8 +292,8 @@ bool VPIntrinsic::canIgnoreVectorLengthParam() const { // Compare vscale patterns uint64_t VScaleFactor; if (match(VLParam, m_c_Mul(m_ConstantInt(VScaleFactor), m_VScale(DL)))) - return VScaleFactor >= EC.getKnownMinValue(); - return (EC.getKnownMinValue() == 1) && match(VLParam, m_VScale(DL)); + return VScaleFactor >= EC.getKnownMinValue(); + return (EC.getKnownMinValue() == 1) && match(VLParam, m_VScale(DL)); } // standard SIMD operation @@ -302,7 +302,7 @@ bool VPIntrinsic::canIgnoreVectorLengthParam() const { return false; uint64_t VLNum = VLConst->getZExtValue(); - if (VLNum >= EC.getKnownMinValue()) + if (VLNum >= EC.getKnownMinValue()) return true; return false; diff --git a/contrib/libs/llvm12/lib/IR/LLVMContext.cpp b/contrib/libs/llvm12/lib/IR/LLVMContext.cpp index 4f29210125..2637420dae 100644 --- a/contrib/libs/llvm12/lib/IR/LLVMContext.cpp +++ b/contrib/libs/llvm12/lib/IR/LLVMContext.cpp @@ -146,18 +146,18 @@ bool LLVMContext::getDiagnosticsHotnessRequested() const { return pImpl->DiagnosticsHotnessRequested; } -void LLVMContext::setDiagnosticsHotnessThreshold(Optional<uint64_t> Threshold) { +void LLVMContext::setDiagnosticsHotnessThreshold(Optional<uint64_t> Threshold) { pImpl->DiagnosticsHotnessThreshold = Threshold; } - + uint64_t LLVMContext::getDiagnosticsHotnessThreshold() const { - return pImpl->DiagnosticsHotnessThreshold.getValueOr(UINT64_MAX); -} - -bool LLVMContext::isDiagnosticsHotnessThresholdSetFromPSI() const { - return !pImpl->DiagnosticsHotnessThreshold.hasValue(); + return pImpl->DiagnosticsHotnessThreshold.getValueOr(UINT64_MAX); } +bool LLVMContext::isDiagnosticsHotnessThresholdSetFromPSI() const { + return !pImpl->DiagnosticsHotnessThreshold.hasValue(); +} + remarks::RemarkStreamer *LLVMContext::getMainRemarkStreamer() { return pImpl->MainRemarkStreamer.get(); } diff --git a/contrib/libs/llvm12/lib/IR/LLVMContextImpl.cpp b/contrib/libs/llvm12/lib/IR/LLVMContextImpl.cpp index e998138ec3..0e7e3d6b31 100644 --- a/contrib/libs/llvm12/lib/IR/LLVMContextImpl.cpp +++ b/contrib/libs/llvm12/lib/IR/LLVMContextImpl.cpp @@ -35,7 +35,7 @@ LLVMContextImpl::LLVMContextImpl(LLVMContext &C) FP128Ty(C, Type::FP128TyID), PPC_FP128Ty(C, Type::PPC_FP128TyID), X86_MMXTy(C, Type::X86_MMXTyID), - X86_AMXTy(C, Type::X86_AMXTyID), + X86_AMXTy(C, Type::X86_AMXTyID), Int1Ty(C, 1), Int8Ty(C, 8), Int16Ty(C, 16), @@ -51,10 +51,10 @@ LLVMContextImpl::~LLVMContextImpl() { delete *OwnedModules.begin(); #ifndef NDEBUG - // Check for metadata references from leaked Values. - for (auto &Pair : ValueMetadata) + // Check for metadata references from leaked Values. + for (auto &Pair : ValueMetadata) Pair.first->dump(); - assert(ValueMetadata.empty() && "Values with metadata have been leaked"); + assert(ValueMetadata.empty() && "Values with metadata have been leaked"); #endif // Drop references for MDNodes. Do this before Values get deleted to avoid @@ -98,7 +98,7 @@ LLVMContextImpl::~LLVMContextImpl() { CAZConstants.clear(); CPNConstants.clear(); UVConstants.clear(); - PVConstants.clear(); + PVConstants.clear(); IntConstants.clear(); FPConstants.clear(); CDSConstants.clear(); @@ -127,16 +127,16 @@ LLVMContextImpl::~LLVMContextImpl() { } void LLVMContextImpl::dropTriviallyDeadConstantArrays() { - SmallSetVector<ConstantArray *, 4> WorkList; - - // When ArrayConstants are of substantial size and only a few in them are - // dead, starting WorkList with all elements of ArrayConstants can be - // wasteful. Instead, starting WorkList with only elements that have empty - // uses. - for (ConstantArray *C : ArrayConstants) - if (C->use_empty()) - WorkList.insert(C); - + SmallSetVector<ConstantArray *, 4> WorkList; + + // When ArrayConstants are of substantial size and only a few in them are + // dead, starting WorkList with all elements of ArrayConstants can be + // wasteful. Instead, starting WorkList with only elements that have empty + // uses. + for (ConstantArray *C : ArrayConstants) + if (C->use_empty()) + WorkList.insert(C); + while (!WorkList.empty()) { ConstantArray *C = WorkList.pop_back_val(); if (C->use_empty()) { @@ -176,7 +176,7 @@ unsigned MDNodeOpsKey::calculateHash(MDNode *N, unsigned Offset) { unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end()); #ifndef NDEBUG { - SmallVector<Metadata *, 8> MDs(drop_begin(N->operands(), Offset)); + SmallVector<Metadata *, 8> MDs(drop_begin(N->operands(), Offset)); unsigned RawHash = calculateHash(MDs); assert(Hash == RawHash && "Expected hash of MDOperand to equal hash of Metadata*"); @@ -220,8 +220,8 @@ void LLVMContextImpl::getSyncScopeNames( SSNs[SSE.second] = SSE.first(); } -/// Gets the OptPassGate for this LLVMContextImpl, which defaults to the -/// singleton OptBisect if not explicitly set. +/// Gets the OptPassGate for this LLVMContextImpl, which defaults to the +/// singleton OptBisect if not explicitly set. OptPassGate &LLVMContextImpl::getOptPassGate() const { if (!OPG) OPG = &(*OptBisector); diff --git a/contrib/libs/llvm12/lib/IR/LLVMContextImpl.h b/contrib/libs/llvm12/lib/IR/LLVMContextImpl.h index 05fd1814e2..f466baf587 100644 --- a/contrib/libs/llvm12/lib/IR/LLVMContextImpl.h +++ b/contrib/libs/llvm12/lib/IR/LLVMContextImpl.h @@ -57,7 +57,7 @@ class Type; class Value; class ValueHandleBase; -using DenseMapAPIntKeyInfo = DenseMapInfo<APInt>; +using DenseMapAPIntKeyInfo = DenseMapInfo<APInt>; struct DenseMapAPFloatKeyInfo { static inline APFloat getEmptyKey() { return APFloat(APFloat::Bogus(), 1); } @@ -346,36 +346,36 @@ template <> struct MDNodeKeyImpl<DISubrange> { } }; -template <> struct MDNodeKeyImpl<DIGenericSubrange> { - Metadata *CountNode; - Metadata *LowerBound; - Metadata *UpperBound; - Metadata *Stride; - - MDNodeKeyImpl(Metadata *CountNode, Metadata *LowerBound, Metadata *UpperBound, - Metadata *Stride) - : CountNode(CountNode), LowerBound(LowerBound), UpperBound(UpperBound), - Stride(Stride) {} - MDNodeKeyImpl(const DIGenericSubrange *N) - : CountNode(N->getRawCountNode()), LowerBound(N->getRawLowerBound()), - UpperBound(N->getRawUpperBound()), Stride(N->getRawStride()) {} - - bool isKeyOf(const DIGenericSubrange *RHS) const { - return (CountNode == RHS->getRawCountNode()) && - (LowerBound == RHS->getRawLowerBound()) && - (UpperBound == RHS->getRawUpperBound()) && - (Stride == RHS->getRawStride()); - } - - unsigned getHashValue() const { - auto *MD = dyn_cast_or_null<ConstantAsMetadata>(CountNode); - if (CountNode && MD) - return hash_combine(cast<ConstantInt>(MD->getValue())->getSExtValue(), - LowerBound, UpperBound, Stride); - return hash_combine(CountNode, LowerBound, UpperBound, Stride); - } -}; - +template <> struct MDNodeKeyImpl<DIGenericSubrange> { + Metadata *CountNode; + Metadata *LowerBound; + Metadata *UpperBound; + Metadata *Stride; + + MDNodeKeyImpl(Metadata *CountNode, Metadata *LowerBound, Metadata *UpperBound, + Metadata *Stride) + : CountNode(CountNode), LowerBound(LowerBound), UpperBound(UpperBound), + Stride(Stride) {} + MDNodeKeyImpl(const DIGenericSubrange *N) + : CountNode(N->getRawCountNode()), LowerBound(N->getRawLowerBound()), + UpperBound(N->getRawUpperBound()), Stride(N->getRawStride()) {} + + bool isKeyOf(const DIGenericSubrange *RHS) const { + return (CountNode == RHS->getRawCountNode()) && + (LowerBound == RHS->getRawLowerBound()) && + (UpperBound == RHS->getRawUpperBound()) && + (Stride == RHS->getRawStride()); + } + + unsigned getHashValue() const { + auto *MD = dyn_cast_or_null<ConstantAsMetadata>(CountNode); + if (CountNode && MD) + return hash_combine(cast<ConstantInt>(MD->getValue())->getSExtValue(), + LowerBound, UpperBound, Stride); + return hash_combine(CountNode, LowerBound, UpperBound, Stride); + } +}; + template <> struct MDNodeKeyImpl<DIEnumerator> { APInt Value; MDString *Name; @@ -427,37 +427,37 @@ template <> struct MDNodeKeyImpl<DIBasicType> { } }; -template <> struct MDNodeKeyImpl<DIStringType> { - unsigned Tag; - MDString *Name; - Metadata *StringLength; - Metadata *StringLengthExp; - uint64_t SizeInBits; - uint32_t AlignInBits; - unsigned Encoding; - - MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *StringLength, - Metadata *StringLengthExp, uint64_t SizeInBits, - uint32_t AlignInBits, unsigned Encoding) - : Tag(Tag), Name(Name), StringLength(StringLength), - StringLengthExp(StringLengthExp), SizeInBits(SizeInBits), - AlignInBits(AlignInBits), Encoding(Encoding) {} - MDNodeKeyImpl(const DIStringType *N) - : Tag(N->getTag()), Name(N->getRawName()), - StringLength(N->getRawStringLength()), - StringLengthExp(N->getRawStringLengthExp()), - SizeInBits(N->getSizeInBits()), AlignInBits(N->getAlignInBits()), - Encoding(N->getEncoding()) {} - - bool isKeyOf(const DIStringType *RHS) const { - return Tag == RHS->getTag() && Name == RHS->getRawName() && - SizeInBits == RHS->getSizeInBits() && - AlignInBits == RHS->getAlignInBits() && - Encoding == RHS->getEncoding(); - } - unsigned getHashValue() const { return hash_combine(Tag, Name, Encoding); } -}; - +template <> struct MDNodeKeyImpl<DIStringType> { + unsigned Tag; + MDString *Name; + Metadata *StringLength; + Metadata *StringLengthExp; + uint64_t SizeInBits; + uint32_t AlignInBits; + unsigned Encoding; + + MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *StringLength, + Metadata *StringLengthExp, uint64_t SizeInBits, + uint32_t AlignInBits, unsigned Encoding) + : Tag(Tag), Name(Name), StringLength(StringLength), + StringLengthExp(StringLengthExp), SizeInBits(SizeInBits), + AlignInBits(AlignInBits), Encoding(Encoding) {} + MDNodeKeyImpl(const DIStringType *N) + : Tag(N->getTag()), Name(N->getRawName()), + StringLength(N->getRawStringLength()), + StringLengthExp(N->getRawStringLengthExp()), + SizeInBits(N->getSizeInBits()), AlignInBits(N->getAlignInBits()), + Encoding(N->getEncoding()) {} + + bool isKeyOf(const DIStringType *RHS) const { + return Tag == RHS->getTag() && Name == RHS->getRawName() && + SizeInBits == RHS->getSizeInBits() && + AlignInBits == RHS->getAlignInBits() && + Encoding == RHS->getEncoding(); + } + unsigned getHashValue() const { return hash_combine(Tag, Name, Encoding); } +}; + template <> struct MDNodeKeyImpl<DIDerivedType> { unsigned Tag; MDString *Name; @@ -566,9 +566,9 @@ template <> struct MDNodeKeyImpl<DICompositeType> { MDString *Identifier; Metadata *Discriminator; Metadata *DataLocation; - Metadata *Associated; - Metadata *Allocated; - Metadata *Rank; + Metadata *Associated; + Metadata *Allocated; + Metadata *Rank; MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, @@ -576,15 +576,15 @@ template <> struct MDNodeKeyImpl<DICompositeType> { Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, Metadata *TemplateParams, MDString *Identifier, Metadata *Discriminator, - Metadata *DataLocation, Metadata *Associated, - Metadata *Allocated, Metadata *Rank) + Metadata *DataLocation, Metadata *Associated, + Metadata *Allocated, Metadata *Rank) : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope), BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits), AlignInBits(AlignInBits), Flags(Flags), Elements(Elements), RuntimeLang(RuntimeLang), VTableHolder(VTableHolder), TemplateParams(TemplateParams), Identifier(Identifier), - Discriminator(Discriminator), DataLocation(DataLocation), - Associated(Associated), Allocated(Allocated), Rank(Rank) {} + Discriminator(Discriminator), DataLocation(DataLocation), + Associated(Associated), Allocated(Allocated), Rank(Rank) {} MDNodeKeyImpl(const DICompositeType *N) : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()), Line(N->getLine()), Scope(N->getRawScope()), @@ -595,9 +595,9 @@ template <> struct MDNodeKeyImpl<DICompositeType> { TemplateParams(N->getRawTemplateParams()), Identifier(N->getRawIdentifier()), Discriminator(N->getRawDiscriminator()), - DataLocation(N->getRawDataLocation()), - Associated(N->getRawAssociated()), Allocated(N->getRawAllocated()), - Rank(N->getRawRank()) {} + DataLocation(N->getRawDataLocation()), + Associated(N->getRawAssociated()), Allocated(N->getRawAllocated()), + Rank(N->getRawRank()) {} bool isKeyOf(const DICompositeType *RHS) const { return Tag == RHS->getTag() && Name == RHS->getRawName() && @@ -612,9 +612,9 @@ template <> struct MDNodeKeyImpl<DICompositeType> { TemplateParams == RHS->getRawTemplateParams() && Identifier == RHS->getRawIdentifier() && Discriminator == RHS->getRawDiscriminator() && - DataLocation == RHS->getRawDataLocation() && - Associated == RHS->getRawAssociated() && - Allocated == RHS->getRawAllocated() && Rank == RHS->getRawRank(); + DataLocation == RHS->getRawDataLocation() && + Associated == RHS->getRawAssociated() && + Allocated == RHS->getRawAllocated() && Rank == RHS->getRawRank(); } unsigned getHashValue() const { @@ -891,28 +891,28 @@ template <> struct MDNodeKeyImpl<DIModule> { MDString *IncludePath; MDString *APINotesFile; unsigned LineNo; - bool IsDecl; + bool IsDecl; MDNodeKeyImpl(Metadata *File, Metadata *Scope, MDString *Name, MDString *ConfigurationMacros, MDString *IncludePath, - MDString *APINotesFile, unsigned LineNo, bool IsDecl) + MDString *APINotesFile, unsigned LineNo, bool IsDecl) : File(File), Scope(Scope), Name(Name), ConfigurationMacros(ConfigurationMacros), IncludePath(IncludePath), - APINotesFile(APINotesFile), LineNo(LineNo), IsDecl(IsDecl) {} + APINotesFile(APINotesFile), LineNo(LineNo), IsDecl(IsDecl) {} MDNodeKeyImpl(const DIModule *N) : File(N->getRawFile()), Scope(N->getRawScope()), Name(N->getRawName()), ConfigurationMacros(N->getRawConfigurationMacros()), IncludePath(N->getRawIncludePath()), - APINotesFile(N->getRawAPINotesFile()), LineNo(N->getLineNo()), - IsDecl(N->getIsDecl()) {} + APINotesFile(N->getRawAPINotesFile()), LineNo(N->getLineNo()), + IsDecl(N->getIsDecl()) {} bool isKeyOf(const DIModule *RHS) const { return Scope == RHS->getRawScope() && Name == RHS->getRawName() && ConfigurationMacros == RHS->getRawConfigurationMacros() && IncludePath == RHS->getRawIncludePath() && APINotesFile == RHS->getRawAPINotesFile() && - File == RHS->getRawFile() && LineNo == RHS->getLineNo() && - IsDecl == RHS->getIsDecl(); + File == RHS->getRawFile() && LineNo == RHS->getLineNo() && + IsDecl == RHS->getIsDecl(); } unsigned getHashValue() const { @@ -1257,54 +1257,54 @@ template <class NodeTy> struct MDNodeInfo { #define HANDLE_MDNODE_LEAF(CLASS) using CLASS##Info = MDNodeInfo<CLASS>; #include "llvm/IR/Metadata.def" -/// Multimap-like storage for metadata attachments. -class MDAttachments { -public: - struct Attachment { - unsigned MDKind; - TrackingMDNodeRef Node; - }; - -private: - SmallVector<Attachment, 1> Attachments; - +/// Multimap-like storage for metadata attachments. +class MDAttachments { +public: + struct Attachment { + unsigned MDKind; + TrackingMDNodeRef Node; + }; + +private: + SmallVector<Attachment, 1> Attachments; + public: bool empty() const { return Attachments.empty(); } size_t size() const { return Attachments.size(); } - /// Returns the first attachment with the given ID or nullptr if no such - /// attachment exists. + /// Returns the first attachment with the given ID or nullptr if no such + /// attachment exists. MDNode *lookup(unsigned ID) const; - /// Appends all attachments with the given ID to \c Result in insertion order. - /// If the global has no attachments with the given ID, or if ID is invalid, - /// leaves Result unchanged. - void get(unsigned ID, SmallVectorImpl<MDNode *> &Result) const; - - /// Appends all attachments for the global to \c Result, sorting by attachment - /// ID. Attachments with the same ID appear in insertion order. This function - /// does \em not clear \c Result. - void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const; - + /// Appends all attachments with the given ID to \c Result in insertion order. + /// If the global has no attachments with the given ID, or if ID is invalid, + /// leaves Result unchanged. + void get(unsigned ID, SmallVectorImpl<MDNode *> &Result) const; + + /// Appends all attachments for the global to \c Result, sorting by attachment + /// ID. Attachments with the same ID appear in insertion order. This function + /// does \em not clear \c Result. + void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const; + /// Set an attachment to a particular node. /// - /// Set the \c ID attachment to \c MD, replacing the current attachments at \c + /// Set the \c ID attachment to \c MD, replacing the current attachments at \c /// ID (if anyway). - void set(unsigned ID, MDNode *MD); + void set(unsigned ID, MDNode *MD); - /// Adds an attachment to a particular node. - void insert(unsigned ID, MDNode &MD); - - /// Remove attachments with the given ID. + /// Adds an attachment to a particular node. + void insert(unsigned ID, MDNode &MD); + + /// Remove attachments with the given ID. /// - /// Remove the attachments at \c ID, if any. + /// Remove the attachments at \c ID, if any. bool erase(unsigned ID); /// Erase matching attachments. /// /// Erases all attachments matching the \c shouldRemove predicate. template <class PredTy> void remove_if(PredTy shouldRemove) { - llvm::erase_if(Attachments, shouldRemove); + llvm::erase_if(Attachments, shouldRemove); } }; @@ -1325,26 +1325,26 @@ public: std::unique_ptr<DiagnosticHandler> DiagHandler; bool RespectDiagnosticFilters = false; bool DiagnosticsHotnessRequested = false; - /// The minimum hotness value a diagnostic needs in order to be included in - /// optimization diagnostics. - /// - /// The threshold is an Optional value, which maps to one of the 3 states: - /// 1). 0 => threshold disabled. All emarks will be printed. - /// 2). positive int => manual threshold by user. Remarks with hotness exceed - /// threshold will be printed. - /// 3). None => 'auto' threshold by user. The actual value is not - /// available at command line, but will be synced with - /// hotness threhold from profile summary during - /// compilation. - /// - /// State 1 and 2 are considered as terminal states. State transition is - /// only allowed from 3 to 2, when the threshold is first synced with profile - /// summary. This ensures that the threshold is set only once and stays - /// constant. - /// - /// If threshold option is not specified, it is disabled (0) by default. - Optional<uint64_t> DiagnosticsHotnessThreshold = 0; - + /// The minimum hotness value a diagnostic needs in order to be included in + /// optimization diagnostics. + /// + /// The threshold is an Optional value, which maps to one of the 3 states: + /// 1). 0 => threshold disabled. All emarks will be printed. + /// 2). positive int => manual threshold by user. Remarks with hotness exceed + /// threshold will be printed. + /// 3). None => 'auto' threshold by user. The actual value is not + /// available at command line, but will be synced with + /// hotness threhold from profile summary during + /// compilation. + /// + /// State 1 and 2 are considered as terminal states. State transition is + /// only allowed from 3 to 2, when the threshold is first synced with profile + /// summary. This ensures that the threshold is set only once and stays + /// constant. + /// + /// If threshold option is not specified, it is disabled (0) by default. + Optional<uint64_t> DiagnosticsHotnessThreshold = 0; + /// The specialized remark streamer used by LLVM's OptimizationRemarkEmitter. std::unique_ptr<LLVMRemarkStreamer> LLVMRS; @@ -1397,15 +1397,15 @@ public: DenseMap<Type *, std::unique_ptr<UndefValue>> UVConstants; - DenseMap<Type *, std::unique_ptr<PoisonValue>> PVConstants; - - StringMap<std::unique_ptr<ConstantDataSequential>> CDSConstants; + DenseMap<Type *, std::unique_ptr<PoisonValue>> PVConstants; + StringMap<std::unique_ptr<ConstantDataSequential>> CDSConstants; + DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *> BlockAddresses; - - DenseMap<const GlobalValue *, DSOLocalEquivalent *> DSOLocalEquivalents; - + + DenseMap<const GlobalValue *, DSOLocalEquivalent *> DSOLocalEquivalents; + ConstantUniqueMap<ConstantExpr> ExprConstants; ConstantUniqueMap<InlineAsm> InlineAsms; @@ -1418,7 +1418,7 @@ public: // Basic type instances. Type VoidTy, LabelTy, HalfTy, BFloatTy, FloatTy, DoubleTy, MetadataTy, TokenTy; - Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy, X86_AMXTy; + Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy, X86_AMXTy; IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty; BumpPtrAllocator Alloc; @@ -1447,8 +1447,8 @@ public: /// CustomMDKindNames - Map to hold the metadata string to ID mapping. StringMap<unsigned> CustomMDKindNames; - /// Collection of metadata used in this context. - DenseMap<const Value *, MDAttachments> ValueMetadata; + /// Collection of metadata used in this context. + DenseMap<const Value *, MDAttachments> ValueMetadata; /// Collection of per-GlobalObject sections used in this context. DenseMap<const GlobalObject *, StringRef> GlobalObjectSections; diff --git a/contrib/libs/llvm12/lib/IR/LLVMRemarkStreamer.cpp b/contrib/libs/llvm12/lib/IR/LLVMRemarkStreamer.cpp index 18b47611c9..ae65ecdf48 100644 --- a/contrib/libs/llvm12/lib/IR/LLVMRemarkStreamer.cpp +++ b/contrib/libs/llvm12/lib/IR/LLVMRemarkStreamer.cpp @@ -92,11 +92,11 @@ char LLVMRemarkSetupFormatError::ID = 0; Expected<std::unique_ptr<ToolOutputFile>> llvm::setupLLVMOptimizationRemarks( LLVMContext &Context, StringRef RemarksFilename, StringRef RemarksPasses, StringRef RemarksFormat, bool RemarksWithHotness, - Optional<uint64_t> RemarksHotnessThreshold) { + Optional<uint64_t> RemarksHotnessThreshold) { if (RemarksWithHotness) Context.setDiagnosticsHotnessRequested(true); - Context.setDiagnosticsHotnessThreshold(RemarksHotnessThreshold); + Context.setDiagnosticsHotnessThreshold(RemarksHotnessThreshold); if (RemarksFilename.empty()) return nullptr; @@ -136,14 +136,14 @@ Expected<std::unique_ptr<ToolOutputFile>> llvm::setupLLVMOptimizationRemarks( return std::move(RemarksFile); } -Error llvm::setupLLVMOptimizationRemarks( - LLVMContext &Context, raw_ostream &OS, StringRef RemarksPasses, - StringRef RemarksFormat, bool RemarksWithHotness, - Optional<uint64_t> RemarksHotnessThreshold) { +Error llvm::setupLLVMOptimizationRemarks( + LLVMContext &Context, raw_ostream &OS, StringRef RemarksPasses, + StringRef RemarksFormat, bool RemarksWithHotness, + Optional<uint64_t> RemarksHotnessThreshold) { if (RemarksWithHotness) Context.setDiagnosticsHotnessRequested(true); - Context.setDiagnosticsHotnessThreshold(RemarksHotnessThreshold); + Context.setDiagnosticsHotnessThreshold(RemarksHotnessThreshold); Expected<remarks::Format> Format = remarks::parseFormat(RemarksFormat); if (Error E = Format.takeError()) diff --git a/contrib/libs/llvm12/lib/IR/LegacyPassManager.cpp b/contrib/libs/llvm12/lib/IR/LegacyPassManager.cpp index 4547c3a012..a25d1e7f1a 100644 --- a/contrib/libs/llvm12/lib/IR/LegacyPassManager.cpp +++ b/contrib/libs/llvm12/lib/IR/LegacyPassManager.cpp @@ -20,8 +20,8 @@ #include "llvm/IR/LegacyPassNameParser.h" #include "llvm/IR/Module.h" #include "llvm/IR/PassTimingInfo.h" -#include "llvm/IR/PrintPasses.h" -#include "llvm/IR/StructuralHash.h" +#include "llvm/IR/PrintPasses.h" +#include "llvm/IR/StructuralHash.h" #include "llvm/Support/Chrono.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" @@ -50,7 +50,7 @@ namespace { enum PassDebugLevel { Disabled, Arguments, Structure, Executions, Details }; -} // namespace +} // namespace static cl::opt<enum PassDebugLevel> PassDebugging("debug-pass", cl::Hidden, @@ -137,7 +137,7 @@ void PMDataManager::emitInstrCountChangedRemark( // remarks. Since it's possible that the first function in the module // doesn't actually contain a basic block, we have to go and find one that's // suitable for emitting remarks. - auto It = llvm::find_if(M, [](const Function &Fn) { return !Fn.empty(); }); + auto It = llvm::find_if(M, [](const Function &Fn) { return !Fn.empty(); }); // Didn't find a function. Quit. if (It == M.end()) @@ -568,12 +568,12 @@ PMTopLevelManager::setLastUser(ArrayRef<Pass*> AnalysisPasses, Pass *P) { PDepth = P->getResolver()->getPMDataManager().getDepth(); for (Pass *AP : AnalysisPasses) { - // Record P as the new last user of AP. - auto &LastUserOfAP = LastUser[AP]; - if (LastUserOfAP) - InversedLastUser[LastUserOfAP].erase(AP); - LastUserOfAP = P; - InversedLastUser[P].insert(AP); + // Record P as the new last user of AP. + auto &LastUserOfAP = LastUser[AP]; + if (LastUserOfAP) + InversedLastUser[LastUserOfAP].erase(AP); + LastUserOfAP = P; + InversedLastUser[P].insert(AP); if (P == AP) continue; @@ -605,23 +605,23 @@ PMTopLevelManager::setLastUser(ArrayRef<Pass*> AnalysisPasses, Pass *P) { // If AP is the last user of other passes then make P last user of // such passes. - auto &LastUsedByAP = InversedLastUser[AP]; - for (Pass *L : LastUsedByAP) - LastUser[L] = P; - InversedLastUser[P].insert(LastUsedByAP.begin(), LastUsedByAP.end()); - LastUsedByAP.clear(); + auto &LastUsedByAP = InversedLastUser[AP]; + for (Pass *L : LastUsedByAP) + LastUser[L] = P; + InversedLastUser[P].insert(LastUsedByAP.begin(), LastUsedByAP.end()); + LastUsedByAP.clear(); } } /// Collect passes whose last user is P void PMTopLevelManager::collectLastUses(SmallVectorImpl<Pass *> &LastUses, Pass *P) { - auto DMI = InversedLastUser.find(P); + auto DMI = InversedLastUser.find(P); if (DMI == InversedLastUser.end()) return; - auto &LU = DMI->second; - LastUses.append(LU.begin(), LU.end()); + auto &LU = DMI->second; + LastUses.append(LU.begin(), LU.end()); } AnalysisUsage *PMTopLevelManager::findAnalysisUsage(Pass *P) { @@ -1151,8 +1151,8 @@ Pass *PMDataManager::findAnalysisPass(AnalysisID AID, bool SearchParent) { // Print list of passes that are last used by P. void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{ - if (PassDebugging < Details) - return; + if (PassDebugging < Details) + return; SmallVector<Pass *, 12> LUses; @@ -1308,8 +1308,8 @@ PMDataManager::~PMDataManager() { //===----------------------------------------------------------------------===// // NOTE: Is this the right place to define this method ? // getAnalysisIfAvailable - Return analysis result or null if it doesn't exist. -Pass *AnalysisResolver::getAnalysisIfAvailable(AnalysisID ID) const { - return PM.findAnalysisPass(ID, true); +Pass *AnalysisResolver::getAnalysisIfAvailable(AnalysisID ID) const { + return PM.findAnalysisPass(ID, true); } std::tuple<Pass *, bool> @@ -1429,19 +1429,19 @@ bool FPPassManager::runOnFunction(Function &F) { { PassManagerPrettyStackEntry X(FP, F); TimeRegion PassTimer(getPassTimer(FP)); -#ifdef EXPENSIVE_CHECKS - uint64_t RefHash = StructuralHash(F); -#endif +#ifdef EXPENSIVE_CHECKS + uint64_t RefHash = StructuralHash(F); +#endif LocalChanged |= FP->runOnFunction(F); - -#if defined(EXPENSIVE_CHECKS) && !defined(NDEBUG) - if (!LocalChanged && (RefHash != StructuralHash(F))) { - llvm::errs() << "Pass modifies its input and doesn't report it: " - << FP->getPassName() << "\n"; - llvm_unreachable("Pass modifies its input and doesn't report it"); - } -#endif - + +#if defined(EXPENSIVE_CHECKS) && !defined(NDEBUG) + if (!LocalChanged && (RefHash != StructuralHash(F))) { + llvm::errs() << "Pass modifies its input and doesn't report it: " + << FP->getPassName() << "\n"; + llvm_unreachable("Pass modifies its input and doesn't report it"); + } +#endif + if (EmitICRemark) { unsigned NewSize = F.getInstructionCount(); @@ -1465,8 +1465,8 @@ bool FPPassManager::runOnFunction(Function &F) { dumpUsedSet(FP); verifyPreservedAnalysis(FP); - if (LocalChanged) - removeNotPreservedAnalysis(FP); + if (LocalChanged) + removeNotPreservedAnalysis(FP); recordAvailableAnalysis(FP); removeDeadPasses(FP, F.getName(), ON_FUNCTION_MSG); } @@ -1543,17 +1543,17 @@ MPPassManager::runOnModule(Module &M) { PassManagerPrettyStackEntry X(MP, M); TimeRegion PassTimer(getPassTimer(MP)); -#ifdef EXPENSIVE_CHECKS - uint64_t RefHash = StructuralHash(M); -#endif - +#ifdef EXPENSIVE_CHECKS + uint64_t RefHash = StructuralHash(M); +#endif + LocalChanged |= MP->runOnModule(M); - -#ifdef EXPENSIVE_CHECKS - assert((LocalChanged || (RefHash == StructuralHash(M))) && - "Pass modifies its input and doesn't report it."); -#endif - + +#ifdef EXPENSIVE_CHECKS + assert((LocalChanged || (RefHash == StructuralHash(M))) && + "Pass modifies its input and doesn't report it."); +#endif + if (EmitICRemark) { // Update the size of the module. unsigned ModuleCount = M.getInstructionCount(); @@ -1575,8 +1575,8 @@ MPPassManager::runOnModule(Module &M) { dumpUsedSet(MP); verifyPreservedAnalysis(MP); - if (LocalChanged) - removeNotPreservedAnalysis(MP); + if (LocalChanged) + removeNotPreservedAnalysis(MP); recordAvailableAnalysis(MP); removeDeadPasses(MP, M.getModuleIdentifier(), ON_MODULE_MSG); } diff --git a/contrib/libs/llvm12/lib/IR/MDBuilder.cpp b/contrib/libs/llvm12/lib/IR/MDBuilder.cpp index 35af849028..1acfa4fe54 100644 --- a/contrib/libs/llvm12/lib/IR/MDBuilder.cpp +++ b/contrib/libs/llvm12/lib/IR/MDBuilder.cpp @@ -151,20 +151,20 @@ MDNode *MDBuilder::mergeCallbackEncodings(MDNode *ExistingCallbacks, } MDNode *MDBuilder::createAnonymousAARoot(StringRef Name, MDNode *Extra) { - SmallVector<Metadata *, 3> Args(1, nullptr); + SmallVector<Metadata *, 3> Args(1, nullptr); if (Extra) Args.push_back(Extra); if (!Name.empty()) Args.push_back(createString(Name)); - MDNode *Root = MDNode::getDistinct(Context, Args); + MDNode *Root = MDNode::getDistinct(Context, Args); // At this point we have - // !0 = distinct !{null} <- root - // Replace the reserved operand with the root node itself. + // !0 = distinct !{null} <- root + // Replace the reserved operand with the root node itself. Root->replaceOperandWith(0, Root); // We now have - // !0 = distinct !{!0} <- root + // !0 = distinct !{!0} <- root return Root; } @@ -306,12 +306,12 @@ MDNode *MDBuilder::createIrrLoopHeaderWeight(uint64_t Weight) { return MDNode::get(Context, Vals); } -MDNode *MDBuilder::createPseudoProbeDesc(uint64_t GUID, uint64_t Hash, - Function *F) { - auto *Int64Ty = Type::getInt64Ty(Context); - SmallVector<Metadata *, 3> Ops(3); - Ops[0] = createConstant(ConstantInt::get(Int64Ty, GUID)); - Ops[1] = createConstant(ConstantInt::get(Int64Ty, Hash)); - Ops[2] = createString(F->getName()); - return MDNode::get(Context, Ops); +MDNode *MDBuilder::createPseudoProbeDesc(uint64_t GUID, uint64_t Hash, + Function *F) { + auto *Int64Ty = Type::getInt64Ty(Context); + SmallVector<Metadata *, 3> Ops(3); + Ops[0] = createConstant(ConstantInt::get(Int64Ty, GUID)); + Ops[1] = createConstant(ConstantInt::get(Int64Ty, Hash)); + Ops[2] = createString(F->getName()); + return MDNode::get(Context, Ops); } diff --git a/contrib/libs/llvm12/lib/IR/Mangler.cpp b/contrib/libs/llvm12/lib/IR/Mangler.cpp index 674ba3cdaa..f067d517b8 100644 --- a/contrib/libs/llvm12/lib/IR/Mangler.cpp +++ b/contrib/libs/llvm12/lib/IR/Mangler.cpp @@ -12,7 +12,7 @@ #include "llvm/IR/Mangler.h" #include "llvm/ADT/SmallString.h" -#include "llvm/ADT/StringExtras.h" +#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/Triple.h" #include "llvm/ADT/Twine.h" #include "llvm/IR/DataLayout.h" @@ -101,7 +101,7 @@ static void addByteCountSuffix(raw_ostream &OS, const Function *F, for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end(); AI != AE; ++AI) { // 'Dereference' type in case of byval or inalloca parameter attribute. - uint64_t AllocSize = AI->hasPassPointeeByValueCopyAttr() ? + uint64_t AllocSize = AI->hasPassPointeeByValueCopyAttr() ? AI->getPassPointeeByValueCopySize(DL) : DL.getTypeAllocSize(AI->getType()); @@ -185,25 +185,25 @@ void Mangler::getNameWithPrefix(SmallVectorImpl<char> &OutName, getNameWithPrefix(OS, GV, CannotUsePrivateLabel); } -// Check if the name needs quotes to be safe for the linker to interpret. -static bool canBeUnquotedInDirective(char C) { - return isAlnum(C) || C == '_' || C == '$' || C == '.' || C == '@'; -} - -static bool canBeUnquotedInDirective(StringRef Name) { - if (Name.empty()) - return false; - - // If any of the characters in the string is an unacceptable character, force - // quotes. - for (char C : Name) { - if (!canBeUnquotedInDirective(C)) - return false; - } - - return true; -} - +// Check if the name needs quotes to be safe for the linker to interpret. +static bool canBeUnquotedInDirective(char C) { + return isAlnum(C) || C == '_' || C == '$' || C == '.' || C == '@'; +} + +static bool canBeUnquotedInDirective(StringRef Name) { + if (Name.empty()) + return false; + + // If any of the characters in the string is an unacceptable character, force + // quotes. + for (char C : Name) { + if (!canBeUnquotedInDirective(C)) + return false; + } + + return true; +} + void llvm::emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &TT, Mangler &Mangler) { if (!GV->hasDLLExportStorageClass() || GV->isDeclaration()) @@ -214,9 +214,9 @@ void llvm::emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, else OS << " -export:"; - bool NeedQuotes = GV->hasName() && !canBeUnquotedInDirective(GV->getName()); - if (NeedQuotes) - OS << "\""; + bool NeedQuotes = GV->hasName() && !canBeUnquotedInDirective(GV->getName()); + if (NeedQuotes) + OS << "\""; if (TT.isWindowsGNUEnvironment() || TT.isWindowsCygwinEnvironment()) { std::string Flag; raw_string_ostream FlagOS(Flag); @@ -229,8 +229,8 @@ void llvm::emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, } else { Mangler.getNameWithPrefix(OS, GV, false); } - if (NeedQuotes) - OS << "\""; + if (NeedQuotes) + OS << "\""; if (!GV->getValueType()->isFunctionTy()) { if (TT.isWindowsMSVCEnvironment()) @@ -246,11 +246,11 @@ void llvm::emitLinkerFlagsForUsedCOFF(raw_ostream &OS, const GlobalValue *GV, return; OS << " /INCLUDE:"; - bool NeedQuotes = GV->hasName() && !canBeUnquotedInDirective(GV->getName()); - if (NeedQuotes) - OS << "\""; + bool NeedQuotes = GV->hasName() && !canBeUnquotedInDirective(GV->getName()); + if (NeedQuotes) + OS << "\""; M.getNameWithPrefix(OS, GV, false); - if (NeedQuotes) - OS << "\""; + if (NeedQuotes) + OS << "\""; } diff --git a/contrib/libs/llvm12/lib/IR/Metadata.cpp b/contrib/libs/llvm12/lib/IR/Metadata.cpp index 7ca538995d..0dd6734cbd 100644 --- a/contrib/libs/llvm12/lib/IR/Metadata.cpp +++ b/contrib/libs/llvm12/lib/IR/Metadata.cpp @@ -10,7 +10,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/IR/Metadata.h" +#include "llvm/IR/Metadata.h" #include "LLVMContextImpl.h" #include "MetadataImpl.h" #include "SymbolTableListTraitsImpl.h" @@ -39,7 +39,7 @@ #include "llvm/IR/GlobalVariable.h" #include "llvm/IR/Instruction.h" #include "llvm/IR/LLVMContext.h" -#include "llvm/IR/MDBuilder.h" +#include "llvm/IR/MDBuilder.h" #include "llvm/IR/Module.h" #include "llvm/IR/TrackingMDRef.h" #include "llvm/IR/Type.h" @@ -641,7 +641,7 @@ void MDNode::resolveCycles() { } static bool hasSelfReference(MDNode *N) { - return llvm::is_contained(N->operands(), N); + return llvm::is_contained(N->operands(), N); } MDNode *MDNode::replaceWithPermanentImpl() { @@ -923,32 +923,32 @@ MDNode *MDNode::getMostGenericAliasScope(MDNode *A, MDNode *B) { if (!A || !B) return nullptr; - // Take the intersection of domains then union the scopes - // within those domains - SmallPtrSet<const MDNode *, 16> ADomains; - SmallPtrSet<const MDNode *, 16> IntersectDomains; - SmallSetVector<Metadata *, 4> MDs; - for (const MDOperand &MDOp : A->operands()) - if (const MDNode *NAMD = dyn_cast<MDNode>(MDOp)) - if (const MDNode *Domain = AliasScopeNode(NAMD).getDomain()) - ADomains.insert(Domain); - - for (const MDOperand &MDOp : B->operands()) - if (const MDNode *NAMD = dyn_cast<MDNode>(MDOp)) - if (const MDNode *Domain = AliasScopeNode(NAMD).getDomain()) - if (ADomains.contains(Domain)) { - IntersectDomains.insert(Domain); - MDs.insert(MDOp); - } - - for (const MDOperand &MDOp : A->operands()) - if (const MDNode *NAMD = dyn_cast<MDNode>(MDOp)) - if (const MDNode *Domain = AliasScopeNode(NAMD).getDomain()) - if (IntersectDomains.contains(Domain)) - MDs.insert(MDOp); - - return MDs.empty() ? nullptr - : getOrSelfReference(A->getContext(), MDs.getArrayRef()); + // Take the intersection of domains then union the scopes + // within those domains + SmallPtrSet<const MDNode *, 16> ADomains; + SmallPtrSet<const MDNode *, 16> IntersectDomains; + SmallSetVector<Metadata *, 4> MDs; + for (const MDOperand &MDOp : A->operands()) + if (const MDNode *NAMD = dyn_cast<MDNode>(MDOp)) + if (const MDNode *Domain = AliasScopeNode(NAMD).getDomain()) + ADomains.insert(Domain); + + for (const MDOperand &MDOp : B->operands()) + if (const MDNode *NAMD = dyn_cast<MDNode>(MDOp)) + if (const MDNode *Domain = AliasScopeNode(NAMD).getDomain()) + if (ADomains.contains(Domain)) { + IntersectDomains.insert(Domain); + MDs.insert(MDOp); + } + + for (const MDOperand &MDOp : A->operands()) + if (const MDNode *NAMD = dyn_cast<MDNode>(MDOp)) + if (const MDNode *Domain = AliasScopeNode(NAMD).getDomain()) + if (IntersectDomains.contains(Domain)) + MDs.insert(MDOp); + + return MDs.empty() ? nullptr + : getOrSelfReference(A->getContext(), MDs.getArrayRef()); } MDNode *MDNode::getMostGenericFPMath(MDNode *A, MDNode *B) { @@ -1124,160 +1124,160 @@ StringRef NamedMDNode::getName() const { return StringRef(Name); } //===----------------------------------------------------------------------===// // Instruction Metadata method implementations. // - -MDNode *MDAttachments::lookup(unsigned ID) const { - for (const auto &A : Attachments) - if (A.MDKind == ID) - return A.Node; - return nullptr; -} - -void MDAttachments::get(unsigned ID, SmallVectorImpl<MDNode *> &Result) const { - for (const auto &A : Attachments) - if (A.MDKind == ID) - Result.push_back(A.Node); -} - -void MDAttachments::getAll( - SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const { - for (const auto &A : Attachments) - Result.emplace_back(A.MDKind, A.Node); - - // Sort the resulting array so it is stable with respect to metadata IDs. We - // need to preserve the original insertion order though. - if (Result.size() > 1) - llvm::stable_sort(Result, less_first()); -} - -void MDAttachments::set(unsigned ID, MDNode *MD) { - erase(ID); - if (MD) - insert(ID, *MD); -} - -void MDAttachments::insert(unsigned ID, MDNode &MD) { - Attachments.push_back({ID, TrackingMDNodeRef(&MD)}); -} - -bool MDAttachments::erase(unsigned ID) { + +MDNode *MDAttachments::lookup(unsigned ID) const { + for (const auto &A : Attachments) + if (A.MDKind == ID) + return A.Node; + return nullptr; +} + +void MDAttachments::get(unsigned ID, SmallVectorImpl<MDNode *> &Result) const { + for (const auto &A : Attachments) + if (A.MDKind == ID) + Result.push_back(A.Node); +} + +void MDAttachments::getAll( + SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const { + for (const auto &A : Attachments) + Result.emplace_back(A.MDKind, A.Node); + + // Sort the resulting array so it is stable with respect to metadata IDs. We + // need to preserve the original insertion order though. + if (Result.size() > 1) + llvm::stable_sort(Result, less_first()); +} + +void MDAttachments::set(unsigned ID, MDNode *MD) { + erase(ID); + if (MD) + insert(ID, *MD); +} + +void MDAttachments::insert(unsigned ID, MDNode &MD) { + Attachments.push_back({ID, TrackingMDNodeRef(&MD)}); +} + +bool MDAttachments::erase(unsigned ID) { if (empty()) return false; - // Common case is one value. - if (Attachments.size() == 1 && Attachments.back().MDKind == ID) { + // Common case is one value. + if (Attachments.size() == 1 && Attachments.back().MDKind == ID) { Attachments.pop_back(); return true; } - auto OldSize = Attachments.size(); - llvm::erase_if(Attachments, - [ID](const Attachment &A) { return A.MDKind == ID; }); - return OldSize != Attachments.size(); -} - -MDNode *Value::getMetadata(unsigned KindID) const { - if (!hasMetadata()) - return nullptr; - const auto &Info = getContext().pImpl->ValueMetadata[this]; - assert(!Info.empty() && "bit out of sync with hash table"); - return Info.lookup(KindID); -} - -MDNode *Value::getMetadata(StringRef Kind) const { - if (!hasMetadata()) - return nullptr; - const auto &Info = getContext().pImpl->ValueMetadata[this]; - assert(!Info.empty() && "bit out of sync with hash table"); - return Info.lookup(getContext().getMDKindID(Kind)); -} - -void Value::getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const { - if (hasMetadata()) - getContext().pImpl->ValueMetadata[this].get(KindID, MDs); -} - -void Value::getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const { - if (hasMetadata()) - getMetadata(getContext().getMDKindID(Kind), MDs); -} - -void Value::getAllMetadata( - SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const { - if (hasMetadata()) { - assert(getContext().pImpl->ValueMetadata.count(this) && - "bit out of sync with hash table"); - const auto &Info = getContext().pImpl->ValueMetadata.find(this)->second; - assert(!Info.empty() && "Shouldn't have called this"); - Info.getAll(MDs); - } -} - -void Value::setMetadata(unsigned KindID, MDNode *Node) { - assert(isa<Instruction>(this) || isa<GlobalObject>(this)); - - // Handle the case when we're adding/updating metadata on a value. - if (Node) { - auto &Info = getContext().pImpl->ValueMetadata[this]; - assert(!Info.empty() == HasMetadata && "bit out of sync with hash table"); - if (Info.empty()) - HasMetadata = true; - Info.set(KindID, Node); - return; - } - - // Otherwise, we're removing metadata from an instruction. - assert((HasMetadata == (getContext().pImpl->ValueMetadata.count(this) > 0)) && - "bit out of sync with hash table"); - if (!HasMetadata) - return; // Nothing to remove! - auto &Info = getContext().pImpl->ValueMetadata[this]; - - // Handle removal of an existing value. - Info.erase(KindID); - if (!Info.empty()) - return; - getContext().pImpl->ValueMetadata.erase(this); - HasMetadata = false; -} - -void Value::setMetadata(StringRef Kind, MDNode *Node) { - if (!Node && !HasMetadata) - return; - setMetadata(getContext().getMDKindID(Kind), Node); -} - -void Value::addMetadata(unsigned KindID, MDNode &MD) { - assert(isa<Instruction>(this) || isa<GlobalObject>(this)); - if (!HasMetadata) - HasMetadata = true; - getContext().pImpl->ValueMetadata[this].insert(KindID, MD); -} - -void Value::addMetadata(StringRef Kind, MDNode &MD) { - addMetadata(getContext().getMDKindID(Kind), MD); -} - -bool Value::eraseMetadata(unsigned KindID) { - // Nothing to unset. - if (!HasMetadata) - return false; - - auto &Store = getContext().pImpl->ValueMetadata[this]; - bool Changed = Store.erase(KindID); - if (Store.empty()) - clearMetadata(); - return Changed; -} - -void Value::clearMetadata() { - if (!HasMetadata) - return; - assert(getContext().pImpl->ValueMetadata.count(this) && - "bit out of sync with hash table"); - getContext().pImpl->ValueMetadata.erase(this); - HasMetadata = false; -} - + auto OldSize = Attachments.size(); + llvm::erase_if(Attachments, + [ID](const Attachment &A) { return A.MDKind == ID; }); + return OldSize != Attachments.size(); +} + +MDNode *Value::getMetadata(unsigned KindID) const { + if (!hasMetadata()) + return nullptr; + const auto &Info = getContext().pImpl->ValueMetadata[this]; + assert(!Info.empty() && "bit out of sync with hash table"); + return Info.lookup(KindID); +} + +MDNode *Value::getMetadata(StringRef Kind) const { + if (!hasMetadata()) + return nullptr; + const auto &Info = getContext().pImpl->ValueMetadata[this]; + assert(!Info.empty() && "bit out of sync with hash table"); + return Info.lookup(getContext().getMDKindID(Kind)); +} + +void Value::getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const { + if (hasMetadata()) + getContext().pImpl->ValueMetadata[this].get(KindID, MDs); +} + +void Value::getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const { + if (hasMetadata()) + getMetadata(getContext().getMDKindID(Kind), MDs); +} + +void Value::getAllMetadata( + SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const { + if (hasMetadata()) { + assert(getContext().pImpl->ValueMetadata.count(this) && + "bit out of sync with hash table"); + const auto &Info = getContext().pImpl->ValueMetadata.find(this)->second; + assert(!Info.empty() && "Shouldn't have called this"); + Info.getAll(MDs); + } +} + +void Value::setMetadata(unsigned KindID, MDNode *Node) { + assert(isa<Instruction>(this) || isa<GlobalObject>(this)); + + // Handle the case when we're adding/updating metadata on a value. + if (Node) { + auto &Info = getContext().pImpl->ValueMetadata[this]; + assert(!Info.empty() == HasMetadata && "bit out of sync with hash table"); + if (Info.empty()) + HasMetadata = true; + Info.set(KindID, Node); + return; + } + + // Otherwise, we're removing metadata from an instruction. + assert((HasMetadata == (getContext().pImpl->ValueMetadata.count(this) > 0)) && + "bit out of sync with hash table"); + if (!HasMetadata) + return; // Nothing to remove! + auto &Info = getContext().pImpl->ValueMetadata[this]; + + // Handle removal of an existing value. + Info.erase(KindID); + if (!Info.empty()) + return; + getContext().pImpl->ValueMetadata.erase(this); + HasMetadata = false; +} + +void Value::setMetadata(StringRef Kind, MDNode *Node) { + if (!Node && !HasMetadata) + return; + setMetadata(getContext().getMDKindID(Kind), Node); +} + +void Value::addMetadata(unsigned KindID, MDNode &MD) { + assert(isa<Instruction>(this) || isa<GlobalObject>(this)); + if (!HasMetadata) + HasMetadata = true; + getContext().pImpl->ValueMetadata[this].insert(KindID, MD); +} + +void Value::addMetadata(StringRef Kind, MDNode &MD) { + addMetadata(getContext().getMDKindID(Kind), MD); +} + +bool Value::eraseMetadata(unsigned KindID) { + // Nothing to unset. + if (!HasMetadata) + return false; + + auto &Store = getContext().pImpl->ValueMetadata[this]; + bool Changed = Store.erase(KindID); + if (Store.empty()) + clearMetadata(); + return Changed; +} + +void Value::clearMetadata() { + if (!HasMetadata) + return; + assert(getContext().pImpl->ValueMetadata.count(this) && + "bit out of sync with hash table"); + getContext().pImpl->ValueMetadata.erase(this); + HasMetadata = false; +} + void Instruction::setMetadata(StringRef Kind, MDNode *Node) { if (!Node && !hasMetadata()) return; @@ -1289,28 +1289,28 @@ MDNode *Instruction::getMetadataImpl(StringRef Kind) const { } void Instruction::dropUnknownNonDebugMetadata(ArrayRef<unsigned> KnownIDs) { - if (!Value::hasMetadata()) + if (!Value::hasMetadata()) return; // Nothing to remove! - if (KnownIDs.empty()) { + if (KnownIDs.empty()) { // Just drop our entry at the store. - clearMetadata(); + clearMetadata(); return; } - SmallSet<unsigned, 4> KnownSet; - KnownSet.insert(KnownIDs.begin(), KnownIDs.end()); - - auto &MetadataStore = getContext().pImpl->ValueMetadata; - auto &Info = MetadataStore[this]; - assert(!Info.empty() && "bit out of sync with hash table"); - Info.remove_if([&KnownSet](const MDAttachments::Attachment &I) { - return !KnownSet.count(I.MDKind); + SmallSet<unsigned, 4> KnownSet; + KnownSet.insert(KnownIDs.begin(), KnownIDs.end()); + + auto &MetadataStore = getContext().pImpl->ValueMetadata; + auto &Info = MetadataStore[this]; + assert(!Info.empty() && "bit out of sync with hash table"); + Info.remove_if([&KnownSet](const MDAttachments::Attachment &I) { + return !KnownSet.count(I.MDKind); }); if (Info.empty()) { // Drop our entry at the store. - clearMetadata(); + clearMetadata(); } } @@ -1324,28 +1324,28 @@ void Instruction::setMetadata(unsigned KindID, MDNode *Node) { return; } - Value::setMetadata(KindID, Node); -} + Value::setMetadata(KindID, Node); +} -void Instruction::addAnnotationMetadata(StringRef Name) { - MDBuilder MDB(getContext()); +void Instruction::addAnnotationMetadata(StringRef Name) { + MDBuilder MDB(getContext()); - auto *Existing = getMetadata(LLVMContext::MD_annotation); - SmallVector<Metadata *, 4> Names; - bool AppendName = true; - if (Existing) { - auto *Tuple = cast<MDTuple>(Existing); - for (auto &N : Tuple->operands()) { - if (cast<MDString>(N.get())->getString() == Name) - AppendName = false; - Names.push_back(N.get()); - } - } - if (AppendName) - Names.push_back(MDB.createString(Name)); + auto *Existing = getMetadata(LLVMContext::MD_annotation); + SmallVector<Metadata *, 4> Names; + bool AppendName = true; + if (Existing) { + auto *Tuple = cast<MDTuple>(Existing); + for (auto &N : Tuple->operands()) { + if (cast<MDString>(N.get())->getString() == Name) + AppendName = false; + Names.push_back(N.get()); + } + } + if (AppendName) + Names.push_back(MDB.createString(Name)); - MDNode *MD = MDTuple::get(getContext(), Names); - setMetadata(LLVMContext::MD_annotation, MD); + MDNode *MD = MDTuple::get(getContext(), Names); + setMetadata(LLVMContext::MD_annotation, MD); } void Instruction::setAAMetadata(const AAMDNodes &N) { @@ -1359,7 +1359,7 @@ MDNode *Instruction::getMetadataImpl(unsigned KindID) const { // Handle 'dbg' as a special case since it is not stored in the hash table. if (KindID == LLVMContext::MD_dbg) return DbgLoc.getAsMDNode(); - return Value::getMetadata(KindID); + return Value::getMetadata(KindID); } void Instruction::getAllMetadataImpl( @@ -1371,7 +1371,7 @@ void Instruction::getAllMetadataImpl( Result.push_back( std::make_pair((unsigned)LLVMContext::MD_dbg, DbgLoc.getAsMDNode())); } - Value::getAllMetadata(Result); + Value::getAllMetadata(Result); } bool Instruction::extractProfMetadata(uint64_t &TrueVal, diff --git a/contrib/libs/llvm12/lib/IR/Module.cpp b/contrib/libs/llvm12/lib/IR/Module.cpp index b4f10e2e2d..2064d50f1e 100644 --- a/contrib/libs/llvm12/lib/IR/Module.cpp +++ b/contrib/libs/llvm12/lib/IR/Module.cpp @@ -582,7 +582,7 @@ void Module::setProfileSummary(Metadata *M, ProfileSummary::Kind Kind) { setModuleFlag(ModFlagBehavior::Error, "ProfileSummary", M); } -Metadata *Module::getProfileSummary(bool IsCS) const { +Metadata *Module::getProfileSummary(bool IsCS) const { return (IsCS ? getModuleFlag("CSProfileSummary") : getModuleFlag("ProfileSummary")); } diff --git a/contrib/libs/llvm12/lib/IR/ModuleSummaryIndex.cpp b/contrib/libs/llvm12/lib/IR/ModuleSummaryIndex.cpp index 5d21ca759f..ca7ebf98c5 100644 --- a/contrib/libs/llvm12/lib/IR/ModuleSummaryIndex.cpp +++ b/contrib/libs/llvm12/lib/IR/ModuleSummaryIndex.cpp @@ -163,9 +163,9 @@ bool ModuleSummaryIndex::isGUIDLive(GlobalValue::GUID GUID) const { return false; } -static void -propagateAttributesToRefs(GlobalValueSummary *S, - DenseSet<ValueInfo> &MarkedNonReadWriteOnly) { +static void +propagateAttributesToRefs(GlobalValueSummary *S, + DenseSet<ValueInfo> &MarkedNonReadWriteOnly) { // If reference is not readonly or writeonly then referenced summary is not // read/writeonly either. Note that: // - All references from GlobalVarSummary are conservatively considered as @@ -176,11 +176,11 @@ propagateAttributesToRefs(GlobalValueSummary *S, // for them. for (auto &VI : S->refs()) { assert(VI.getAccessSpecifier() == 0 || isa<FunctionSummary>(S)); - if (!VI.getAccessSpecifier()) { - if (!MarkedNonReadWriteOnly.insert(VI).second) - continue; - } else if (MarkedNonReadWriteOnly.contains(VI)) - continue; + if (!VI.getAccessSpecifier()) { + if (!MarkedNonReadWriteOnly.insert(VI).second) + continue; + } else if (MarkedNonReadWriteOnly.contains(VI)) + continue; for (auto &Ref : VI.getSummaryList()) // If references to alias is not read/writeonly then aliasee // is not read/writeonly @@ -223,24 +223,24 @@ void ModuleSummaryIndex::propagateAttributes( const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) { if (!PropagateAttrs) return; - DenseSet<ValueInfo> MarkedNonReadWriteOnly; + DenseSet<ValueInfo> MarkedNonReadWriteOnly; for (auto &P : *this) for (auto &S : P.second.SummaryList) { - if (!isGlobalValueLive(S.get())) { - // computeDeadSymbols should have marked all copies live. Note that - // it is possible that there is a GUID collision between internal - // symbols with the same name in different files of the same name but - // not enough distinguishing path. Because computeDeadSymbols should - // conservatively mark all copies live we can assert here that all are - // dead if any copy is dead. - assert(llvm::none_of( - P.second.SummaryList, - [&](const std::unique_ptr<GlobalValueSummary> &Summary) { - return isGlobalValueLive(Summary.get()); - })); + if (!isGlobalValueLive(S.get())) { + // computeDeadSymbols should have marked all copies live. Note that + // it is possible that there is a GUID collision between internal + // symbols with the same name in different files of the same name but + // not enough distinguishing path. Because computeDeadSymbols should + // conservatively mark all copies live we can assert here that all are + // dead if any copy is dead. + assert(llvm::none_of( + P.second.SummaryList, + [&](const std::unique_ptr<GlobalValueSummary> &Summary) { + return isGlobalValueLive(Summary.get()); + })); // We don't examine references from dead objects - break; - } + break; + } // Global variable can't be marked read/writeonly if it is not eligible // to import since we need to ensure that all external references get @@ -260,7 +260,7 @@ void ModuleSummaryIndex::propagateAttributes( GVS->setReadOnly(false); GVS->setWriteOnly(false); } - propagateAttributesToRefs(S.get(), MarkedNonReadWriteOnly); + propagateAttributesToRefs(S.get(), MarkedNonReadWriteOnly); } setWithAttributePropagation(); if (llvm::AreStatisticsEnabled()) diff --git a/contrib/libs/llvm12/lib/IR/Operator.cpp b/contrib/libs/llvm12/lib/IR/Operator.cpp index 69181f3582..b22afc4300 100644 --- a/contrib/libs/llvm12/lib/IR/Operator.cpp +++ b/contrib/libs/llvm12/lib/IR/Operator.cpp @@ -61,17 +61,17 @@ Align GEPOperator::getMaxPreservedAlignment(const DataLayout &DL) const { bool GEPOperator::accumulateConstantOffset( const DataLayout &DL, APInt &Offset, function_ref<bool(Value &, APInt &)> ExternalAnalysis) const { - assert(Offset.getBitWidth() == - DL.getIndexSizeInBits(getPointerAddressSpace()) && - "The offset bit width does not match DL specification."); - SmallVector<const Value *> Index(value_op_begin() + 1, value_op_end()); - return GEPOperator::accumulateConstantOffset(getSourceElementType(), Index, - DL, Offset, ExternalAnalysis); -} + assert(Offset.getBitWidth() == + DL.getIndexSizeInBits(getPointerAddressSpace()) && + "The offset bit width does not match DL specification."); + SmallVector<const Value *> Index(value_op_begin() + 1, value_op_end()); + return GEPOperator::accumulateConstantOffset(getSourceElementType(), Index, + DL, Offset, ExternalAnalysis); +} -bool GEPOperator::accumulateConstantOffset( - Type *SourceType, ArrayRef<const Value *> Index, const DataLayout &DL, - APInt &Offset, function_ref<bool(Value &, APInt &)> ExternalAnalysis) { +bool GEPOperator::accumulateConstantOffset( + Type *SourceType, ArrayRef<const Value *> Index, const DataLayout &DL, + APInt &Offset, function_ref<bool(Value &, APInt &)> ExternalAnalysis) { bool UsedExternalAnalysis = false; auto AccumulateOffset = [&](APInt Index, uint64_t Size) -> bool { Index = Index.sextOrTrunc(Offset.getBitWidth()); @@ -92,10 +92,10 @@ bool GEPOperator::accumulateConstantOffset( } return true; }; - auto begin = generic_gep_type_iterator<decltype(Index.begin())>::begin( - SourceType, Index.begin()); - auto end = generic_gep_type_iterator<decltype(Index.end())>::end(Index.end()); - for (auto GTI = begin, GTE = end; GTI != GTE; ++GTI) { + auto begin = generic_gep_type_iterator<decltype(Index.begin())>::begin( + SourceType, Index.begin()); + auto end = generic_gep_type_iterator<decltype(Index.end())>::end(Index.end()); + for (auto GTI = begin, GTE = end; GTI != GTE; ++GTI) { // Scalable vectors are multiplied by a runtime constant. bool ScalableType = false; if (isa<ScalableVectorType>(GTI.getIndexedType())) diff --git a/contrib/libs/llvm12/lib/IR/OptBisect.cpp b/contrib/libs/llvm12/lib/IR/OptBisect.cpp index dc85e1316d..9a88d3a1b9 100644 --- a/contrib/libs/llvm12/lib/IR/OptBisect.cpp +++ b/contrib/libs/llvm12/lib/IR/OptBisect.cpp @@ -54,5 +54,5 @@ bool OptBisect::checkPass(const StringRef PassName, printPassMessage(PassName, CurBisectNum, TargetDesc, ShouldRun); return ShouldRun; } - -ManagedStatic<OptBisect> llvm::OptBisector; + +ManagedStatic<OptBisect> llvm::OptBisector; diff --git a/contrib/libs/llvm12/lib/IR/Pass.cpp b/contrib/libs/llvm12/lib/IR/Pass.cpp index 755ea57c63..7ac9d618b6 100644 --- a/contrib/libs/llvm12/lib/IR/Pass.cpp +++ b/contrib/libs/llvm12/lib/IR/Pass.cpp @@ -62,7 +62,7 @@ bool ModulePass::skipModule(Module &M) const { } bool Pass::mustPreserveAnalysisID(char &AID) const { - return Resolver->getAnalysisIfAvailable(&AID) != nullptr; + return Resolver->getAnalysisIfAvailable(&AID) != nullptr; } // dumpPassStructure - Implement the -debug-pass=Structure option @@ -259,23 +259,23 @@ void AnalysisUsage::setPreservesCFG() { AnalysisUsage &AnalysisUsage::addPreserved(StringRef Arg) { const PassInfo *PI = Pass::lookupPassInfo(Arg); // If the pass exists, preserve it. Otherwise silently do nothing. - if (PI) - pushUnique(Preserved, PI->getTypeInfo()); + if (PI) + pushUnique(Preserved, PI->getTypeInfo()); return *this; } AnalysisUsage &AnalysisUsage::addRequiredID(const void *ID) { - pushUnique(Required, ID); + pushUnique(Required, ID); return *this; } AnalysisUsage &AnalysisUsage::addRequiredID(char &ID) { - pushUnique(Required, &ID); + pushUnique(Required, &ID); return *this; } AnalysisUsage &AnalysisUsage::addRequiredTransitiveID(char &ID) { - pushUnique(Required, &ID); - pushUnique(RequiredTransitive, &ID); + pushUnique(Required, &ID); + pushUnique(RequiredTransitive, &ID); return *this; } diff --git a/contrib/libs/llvm12/lib/IR/PassInstrumentation.cpp b/contrib/libs/llvm12/lib/IR/PassInstrumentation.cpp index 56a36db21e..cea4f023e4 100644 --- a/contrib/libs/llvm12/lib/IR/PassInstrumentation.cpp +++ b/contrib/libs/llvm12/lib/IR/PassInstrumentation.cpp @@ -12,29 +12,29 @@ //===----------------------------------------------------------------------===// #include "llvm/IR/PassInstrumentation.h" -#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/STLExtras.h" #include "llvm/IR/PassManager.h" namespace llvm { -void PassInstrumentationCallbacks::addClassToPassName(StringRef ClassName, - StringRef PassName) { - ClassToPassName[ClassName] = PassName.str(); -} - -StringRef -PassInstrumentationCallbacks::getPassNameForClassName(StringRef ClassName) { - return ClassToPassName[ClassName]; -} - +void PassInstrumentationCallbacks::addClassToPassName(StringRef ClassName, + StringRef PassName) { + ClassToPassName[ClassName] = PassName.str(); +} + +StringRef +PassInstrumentationCallbacks::getPassNameForClassName(StringRef ClassName) { + return ClassToPassName[ClassName]; +} + AnalysisKey PassInstrumentationAnalysis::Key; -bool isSpecialPass(StringRef PassID, const std::vector<StringRef> &Specials) { - size_t Pos = PassID.find('<'); - StringRef Prefix = PassID; - if (Pos != StringRef::npos) - Prefix = PassID.substr(0, Pos); - return any_of(Specials, [Prefix](StringRef S) { return Prefix.endswith(S); }); -} - +bool isSpecialPass(StringRef PassID, const std::vector<StringRef> &Specials) { + size_t Pos = PassID.find('<'); + StringRef Prefix = PassID; + if (Pos != StringRef::npos) + Prefix = PassID.substr(0, Pos); + return any_of(Specials, [Prefix](StringRef S) { return Prefix.endswith(S); }); +} + } // namespace llvm diff --git a/contrib/libs/llvm12/lib/IR/PassManager.cpp b/contrib/libs/llvm12/lib/IR/PassManager.cpp index 4cf7ab2a60..8a64175049 100644 --- a/contrib/libs/llvm12/lib/IR/PassManager.cpp +++ b/contrib/libs/llvm12/lib/IR/PassManager.cpp @@ -91,54 +91,54 @@ bool FunctionAnalysisManagerModuleProxy::Result::invalidate( } } // namespace llvm -PreservedAnalyses ModuleToFunctionPassAdaptor::run(Module &M, - ModuleAnalysisManager &AM) { - FunctionAnalysisManager &FAM = - AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager(); - - // Request PassInstrumentation from analysis manager, will use it to run - // instrumenting callbacks for the passes later. - PassInstrumentation PI = AM.getResult<PassInstrumentationAnalysis>(M); - - PreservedAnalyses PA = PreservedAnalyses::all(); - for (Function &F : M) { - if (F.isDeclaration()) - continue; - - // Check the PassInstrumentation's BeforePass callbacks before running the - // pass, skip its execution completely if asked to (callback returns - // false). - if (!PI.runBeforePass<Function>(*Pass, F)) - continue; - - PreservedAnalyses PassPA; - { - TimeTraceScope TimeScope(Pass->name(), F.getName()); - PassPA = Pass->run(F, FAM); - } - - PI.runAfterPass(*Pass, F, PassPA); - - // We know that the function pass couldn't have invalidated any other - // function's analyses (that's the contract of a function pass), so - // directly handle the function analysis manager's invalidation here. - FAM.invalidate(F, PassPA); - - // Then intersect the preserved set so that invalidation of module - // analyses will eventually occur when the module pass completes. - PA.intersect(std::move(PassPA)); - } - - // The FunctionAnalysisManagerModuleProxy is preserved because (we assume) - // the function passes we ran didn't add or remove any functions. - // - // We also preserve all analyses on Functions, because we did all the - // invalidation we needed to do above. - PA.preserveSet<AllAnalysesOn<Function>>(); - PA.preserve<FunctionAnalysisManagerModuleProxy>(); - return PA; -} - +PreservedAnalyses ModuleToFunctionPassAdaptor::run(Module &M, + ModuleAnalysisManager &AM) { + FunctionAnalysisManager &FAM = + AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager(); + + // Request PassInstrumentation from analysis manager, will use it to run + // instrumenting callbacks for the passes later. + PassInstrumentation PI = AM.getResult<PassInstrumentationAnalysis>(M); + + PreservedAnalyses PA = PreservedAnalyses::all(); + for (Function &F : M) { + if (F.isDeclaration()) + continue; + + // Check the PassInstrumentation's BeforePass callbacks before running the + // pass, skip its execution completely if asked to (callback returns + // false). + if (!PI.runBeforePass<Function>(*Pass, F)) + continue; + + PreservedAnalyses PassPA; + { + TimeTraceScope TimeScope(Pass->name(), F.getName()); + PassPA = Pass->run(F, FAM); + } + + PI.runAfterPass(*Pass, F, PassPA); + + // We know that the function pass couldn't have invalidated any other + // function's analyses (that's the contract of a function pass), so + // directly handle the function analysis manager's invalidation here. + FAM.invalidate(F, PassPA); + + // Then intersect the preserved set so that invalidation of module + // analyses will eventually occur when the module pass completes. + PA.intersect(std::move(PassPA)); + } + + // The FunctionAnalysisManagerModuleProxy is preserved because (we assume) + // the function passes we ran didn't add or remove any functions. + // + // We also preserve all analyses on Functions, because we did all the + // invalidation we needed to do above. + PA.preserveSet<AllAnalysesOn<Function>>(); + PA.preserve<FunctionAnalysisManagerModuleProxy>(); + return PA; +} + AnalysisSetKey CFGAnalyses::SetKey; AnalysisSetKey PreservedAnalyses::AllAnalysesKey; diff --git a/contrib/libs/llvm12/lib/IR/PassRegistry.cpp b/contrib/libs/llvm12/lib/IR/PassRegistry.cpp index 94f607afec..20a5bce75e 100644 --- a/contrib/libs/llvm12/lib/IR/PassRegistry.cpp +++ b/contrib/libs/llvm12/lib/IR/PassRegistry.cpp @@ -40,12 +40,12 @@ PassRegistry::~PassRegistry() = default; const PassInfo *PassRegistry::getPassInfo(const void *TI) const { sys::SmartScopedReader<true> Guard(Lock); - return PassInfoMap.lookup(TI); + return PassInfoMap.lookup(TI); } const PassInfo *PassRegistry::getPassInfo(StringRef Arg) const { sys::SmartScopedReader<true> Guard(Lock); - return PassInfoStringMap.lookup(Arg); + return PassInfoStringMap.lookup(Arg); } //===----------------------------------------------------------------------===// diff --git a/contrib/libs/llvm12/lib/IR/PassTimingInfo.cpp b/contrib/libs/llvm12/lib/IR/PassTimingInfo.cpp index d0c1517f48..47c1f9d1d5 100644 --- a/contrib/libs/llvm12/lib/IR/PassTimingInfo.cpp +++ b/contrib/libs/llvm12/lib/IR/PassTimingInfo.cpp @@ -24,7 +24,7 @@ #include "llvm/Support/FormatVariadic.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/Mutex.h" -#include "llvm/Support/TypeName.h" +#include "llvm/Support/TypeName.h" #include "llvm/Support/raw_ostream.h" #include <string> @@ -35,17 +35,17 @@ using namespace llvm; namespace llvm { bool TimePassesIsEnabled = false; -bool TimePassesPerRun = false; +bool TimePassesPerRun = false; static cl::opt<bool, true> EnableTiming( "time-passes", cl::location(TimePassesIsEnabled), cl::Hidden, cl::desc("Time each pass, printing elapsed time for each on exit")); -static cl::opt<bool, true> EnableTimingPerRun( - "time-passes-per-run", cl::location(TimePassesPerRun), cl::Hidden, - cl::desc("Time each pass run, printing elapsed time for each run on exit"), - cl::callback([](const bool &) { TimePassesIsEnabled = true; })); - +static cl::opt<bool, true> EnableTimingPerRun( + "time-passes-per-run", cl::location(TimePassesPerRun), cl::Hidden, + cl::desc("Time each pass run, printing elapsed time for each run on exit"), + cl::callback([](const bool &) { TimePassesIsEnabled = true; })); + namespace { namespace legacy { @@ -171,13 +171,13 @@ void reportAndResetTimings(raw_ostream *OutStream) { /// Returns the timer for the specified pass invocation of \p PassID. /// Each time it creates a new timer. Timer &TimePassesHandler::getPassTimer(StringRef PassID) { - if (!PerRun) { - TimerVector &Timers = TimingData[PassID]; - if (Timers.size() == 0) - Timers.emplace_back(new Timer(PassID, PassID, TG)); - return *Timers.front(); - } - + if (!PerRun) { + TimerVector &Timers = TimingData[PassID]; + if (Timers.size() == 0) + Timers.emplace_back(new Timer(PassID, PassID, TG)); + return *Timers.front(); + } + // Take a vector of Timers created for this \p PassID and append // one more timer to it. TimerVector &Timers = TimingData[PassID]; @@ -192,13 +192,13 @@ Timer &TimePassesHandler::getPassTimer(StringRef PassID) { return *T; } -TimePassesHandler::TimePassesHandler(bool Enabled, bool PerRun) - : TG("pass", "... Pass execution timing report ..."), Enabled(Enabled), - PerRun(PerRun) {} - -TimePassesHandler::TimePassesHandler() - : TimePassesHandler(TimePassesIsEnabled, TimePassesPerRun) {} +TimePassesHandler::TimePassesHandler(bool Enabled, bool PerRun) + : TG("pass", "... Pass execution timing report ..."), Enabled(Enabled), + PerRun(PerRun) {} +TimePassesHandler::TimePassesHandler() + : TimePassesHandler(TimePassesIsEnabled, TimePassesPerRun) {} + void TimePassesHandler::setOutStream(raw_ostream &Out) { OutStream = &Out; } @@ -248,10 +248,10 @@ void TimePassesHandler::stopTimer(StringRef PassID) { MyTimer->stopTimer(); } -void TimePassesHandler::runBeforePass(StringRef PassID) { - if (isSpecialPass(PassID, - {"PassManager", "PassAdaptor", "AnalysisManagerProxy"})) - return; +void TimePassesHandler::runBeforePass(StringRef PassID) { + if (isSpecialPass(PassID, + {"PassManager", "PassAdaptor", "AnalysisManagerProxy"})) + return; startTimer(PassID); @@ -260,8 +260,8 @@ void TimePassesHandler::runBeforePass(StringRef PassID) { } void TimePassesHandler::runAfterPass(StringRef PassID) { - if (isSpecialPass(PassID, - {"PassManager", "PassAdaptor", "AnalysisManagerProxy"})) + if (isSpecialPass(PassID, + {"PassManager", "PassAdaptor", "AnalysisManagerProxy"})) return; stopTimer(PassID); @@ -274,16 +274,16 @@ void TimePassesHandler::registerCallbacks(PassInstrumentationCallbacks &PIC) { if (!Enabled) return; - PIC.registerBeforeNonSkippedPassCallback( - [this](StringRef P, Any) { this->runBeforePass(P); }); + PIC.registerBeforeNonSkippedPassCallback( + [this](StringRef P, Any) { this->runBeforePass(P); }); PIC.registerAfterPassCallback( - [this](StringRef P, Any, const PreservedAnalyses &) { - this->runAfterPass(P); - }); + [this](StringRef P, Any, const PreservedAnalyses &) { + this->runAfterPass(P); + }); PIC.registerAfterPassInvalidatedCallback( - [this](StringRef P, const PreservedAnalyses &) { - this->runAfterPass(P); - }); + [this](StringRef P, const PreservedAnalyses &) { + this->runAfterPass(P); + }); PIC.registerBeforeAnalysisCallback( [this](StringRef P, Any) { this->runBeforePass(P); }); PIC.registerAfterAnalysisCallback( diff --git a/contrib/libs/llvm12/lib/IR/PrintPasses.cpp b/contrib/libs/llvm12/lib/IR/PrintPasses.cpp index 83b8c93e76..bda40d173b 100644 --- a/contrib/libs/llvm12/lib/IR/PrintPasses.cpp +++ b/contrib/libs/llvm12/lib/IR/PrintPasses.cpp @@ -1,88 +1,88 @@ -//===- PrintPasses.cpp ----------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#include "llvm/IR/PrintPasses.h" -#include "llvm/Support/CommandLine.h" -#include <unordered_set> - -using namespace llvm; - -// Print IR out before/after specified passes. -static cl::list<std::string> - PrintBefore("print-before", - llvm::cl::desc("Print IR before specified passes"), - cl::CommaSeparated, cl::Hidden); - -static cl::list<std::string> - PrintAfter("print-after", llvm::cl::desc("Print IR after specified passes"), - cl::CommaSeparated, cl::Hidden); - -static cl::opt<bool> PrintBeforeAll("print-before-all", - llvm::cl::desc("Print IR before each pass"), - cl::init(false), cl::Hidden); -static cl::opt<bool> PrintAfterAll("print-after-all", - llvm::cl::desc("Print IR after each pass"), - cl::init(false), cl::Hidden); - -static cl::opt<bool> - PrintModuleScope("print-module-scope", - cl::desc("When printing IR for print-[before|after]{-all} " - "always print a module IR"), - cl::init(false), cl::Hidden); - -static cl::list<std::string> - PrintFuncsList("filter-print-funcs", cl::value_desc("function names"), - cl::desc("Only print IR for functions whose name " - "match this for all print-[before|after][-all] " - "options"), - cl::CommaSeparated, cl::Hidden); - -/// This is a helper to determine whether to print IR before or -/// after a pass. - -bool llvm::shouldPrintBeforeSomePass() { - return PrintBeforeAll || !PrintBefore.empty(); -} - -bool llvm::shouldPrintAfterSomePass() { - return PrintAfterAll || !PrintAfter.empty(); -} - -static bool shouldPrintBeforeOrAfterPass(StringRef PassID, - ArrayRef<std::string> PassesToPrint) { - return llvm::is_contained(PassesToPrint, PassID); -} - -bool llvm::shouldPrintBeforeAll() { return PrintBeforeAll; } - -bool llvm::shouldPrintAfterAll() { return PrintAfterAll; } - -bool llvm::shouldPrintBeforePass(StringRef PassID) { - return PrintBeforeAll || shouldPrintBeforeOrAfterPass(PassID, PrintBefore); -} - -bool llvm::shouldPrintAfterPass(StringRef PassID) { - return PrintAfterAll || shouldPrintBeforeOrAfterPass(PassID, PrintAfter); -} - -std::vector<std::string> llvm::printBeforePasses() { - return std::vector<std::string>(PrintBefore); -} - -std::vector<std::string> llvm::printAfterPasses() { - return std::vector<std::string>(PrintAfter); -} - -bool llvm::forcePrintModuleIR() { return PrintModuleScope; } - -bool llvm::isFunctionInPrintList(StringRef FunctionName) { - static std::unordered_set<std::string> PrintFuncNames(PrintFuncsList.begin(), - PrintFuncsList.end()); - return PrintFuncNames.empty() || - PrintFuncNames.count(std::string(FunctionName)); -} +//===- PrintPasses.cpp ----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "llvm/IR/PrintPasses.h" +#include "llvm/Support/CommandLine.h" +#include <unordered_set> + +using namespace llvm; + +// Print IR out before/after specified passes. +static cl::list<std::string> + PrintBefore("print-before", + llvm::cl::desc("Print IR before specified passes"), + cl::CommaSeparated, cl::Hidden); + +static cl::list<std::string> + PrintAfter("print-after", llvm::cl::desc("Print IR after specified passes"), + cl::CommaSeparated, cl::Hidden); + +static cl::opt<bool> PrintBeforeAll("print-before-all", + llvm::cl::desc("Print IR before each pass"), + cl::init(false), cl::Hidden); +static cl::opt<bool> PrintAfterAll("print-after-all", + llvm::cl::desc("Print IR after each pass"), + cl::init(false), cl::Hidden); + +static cl::opt<bool> + PrintModuleScope("print-module-scope", + cl::desc("When printing IR for print-[before|after]{-all} " + "always print a module IR"), + cl::init(false), cl::Hidden); + +static cl::list<std::string> + PrintFuncsList("filter-print-funcs", cl::value_desc("function names"), + cl::desc("Only print IR for functions whose name " + "match this for all print-[before|after][-all] " + "options"), + cl::CommaSeparated, cl::Hidden); + +/// This is a helper to determine whether to print IR before or +/// after a pass. + +bool llvm::shouldPrintBeforeSomePass() { + return PrintBeforeAll || !PrintBefore.empty(); +} + +bool llvm::shouldPrintAfterSomePass() { + return PrintAfterAll || !PrintAfter.empty(); +} + +static bool shouldPrintBeforeOrAfterPass(StringRef PassID, + ArrayRef<std::string> PassesToPrint) { + return llvm::is_contained(PassesToPrint, PassID); +} + +bool llvm::shouldPrintBeforeAll() { return PrintBeforeAll; } + +bool llvm::shouldPrintAfterAll() { return PrintAfterAll; } + +bool llvm::shouldPrintBeforePass(StringRef PassID) { + return PrintBeforeAll || shouldPrintBeforeOrAfterPass(PassID, PrintBefore); +} + +bool llvm::shouldPrintAfterPass(StringRef PassID) { + return PrintAfterAll || shouldPrintBeforeOrAfterPass(PassID, PrintAfter); +} + +std::vector<std::string> llvm::printBeforePasses() { + return std::vector<std::string>(PrintBefore); +} + +std::vector<std::string> llvm::printAfterPasses() { + return std::vector<std::string>(PrintAfter); +} + +bool llvm::forcePrintModuleIR() { return PrintModuleScope; } + +bool llvm::isFunctionInPrintList(StringRef FunctionName) { + static std::unordered_set<std::string> PrintFuncNames(PrintFuncsList.begin(), + PrintFuncsList.end()); + return PrintFuncNames.empty() || + PrintFuncNames.count(std::string(FunctionName)); +} diff --git a/contrib/libs/llvm12/lib/IR/ProfileSummary.cpp b/contrib/libs/llvm12/lib/IR/ProfileSummary.cpp index 453a278a7f..7cef3bc83d 100644 --- a/contrib/libs/llvm12/lib/IR/ProfileSummary.cpp +++ b/contrib/libs/llvm12/lib/IR/ProfileSummary.cpp @@ -259,7 +259,7 @@ void ProfileSummary::printSummary(raw_ostream &OS) { void ProfileSummary::printDetailedSummary(raw_ostream &OS) { OS << "Detailed summary:\n"; - for (const auto &Entry : DetailedSummary) { + for (const auto &Entry : DetailedSummary) { OS << Entry.NumCounts << " blocks with count >= " << Entry.MinCount << " account for " << format("%0.6g", (float)Entry.Cutoff / Scale * 100) diff --git a/contrib/libs/llvm12/lib/IR/PseudoProbe.cpp b/contrib/libs/llvm12/lib/IR/PseudoProbe.cpp index 80d2963938..24f38b8888 100644 --- a/contrib/libs/llvm12/lib/IR/PseudoProbe.cpp +++ b/contrib/libs/llvm12/lib/IR/PseudoProbe.cpp @@ -1,99 +1,99 @@ -//===- PseudoProbe.cpp - Pseudo Probe Helpers -----------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file implements the helpers to manipulate pseudo probe IR intrinsic -// calls. -// -//===----------------------------------------------------------------------===// - -#include "llvm/IR/PseudoProbe.h" -#include "llvm/IR/DebugInfoMetadata.h" -#include "llvm/IR/IRBuilder.h" -#include "llvm/IR/Instruction.h" - -using namespace llvm; - -namespace llvm { - -Optional<PseudoProbe> extractProbeFromDiscriminator(const Instruction &Inst) { - assert(isa<CallBase>(&Inst) && !isa<IntrinsicInst>(&Inst) && - "Only call instructions should have pseudo probe encodes as their " - "Dwarf discriminators"); - if (const DebugLoc &DLoc = Inst.getDebugLoc()) { - const DILocation *DIL = DLoc; - auto Discriminator = DIL->getDiscriminator(); - if (DILocation::isPseudoProbeDiscriminator(Discriminator)) { - PseudoProbe Probe; - Probe.Id = - PseudoProbeDwarfDiscriminator::extractProbeIndex(Discriminator); - Probe.Type = - PseudoProbeDwarfDiscriminator::extractProbeType(Discriminator); - Probe.Attr = - PseudoProbeDwarfDiscriminator::extractProbeAttributes(Discriminator); - Probe.Factor = - PseudoProbeDwarfDiscriminator::extractProbeFactor(Discriminator) / - (float)PseudoProbeDwarfDiscriminator::FullDistributionFactor; - return Probe; - } - } - return None; -} - -Optional<PseudoProbe> extractProbe(const Instruction &Inst) { - if (const auto *II = dyn_cast<PseudoProbeInst>(&Inst)) { - PseudoProbe Probe; - Probe.Id = II->getIndex()->getZExtValue(); - Probe.Type = (uint32_t)PseudoProbeType::Block; - Probe.Attr = II->getAttributes()->getZExtValue(); - Probe.Factor = II->getFactor()->getZExtValue() / - (float)PseudoProbeFullDistributionFactor; - return Probe; - } - - if (isa<CallBase>(&Inst) && !isa<IntrinsicInst>(&Inst)) - return extractProbeFromDiscriminator(Inst); - - return None; -} - -void setProbeDistributionFactor(Instruction &Inst, float Factor) { - assert(Factor >= 0 && Factor <= 1 && - "Distribution factor must be in [0, 1.0]"); - if (auto *II = dyn_cast<PseudoProbeInst>(&Inst)) { - IRBuilder<> Builder(&Inst); - uint64_t IntFactor = PseudoProbeFullDistributionFactor; - if (Factor < 1) - IntFactor *= Factor; - auto OrigFactor = II->getFactor()->getZExtValue(); - if (IntFactor != OrigFactor) - II->replaceUsesOfWith(II->getFactor(), Builder.getInt64(IntFactor)); - } else if (isa<CallBase>(&Inst) && !isa<IntrinsicInst>(&Inst)) { - if (const DebugLoc &DLoc = Inst.getDebugLoc()) { - const DILocation *DIL = DLoc; - auto Discriminator = DIL->getDiscriminator(); - if (DILocation::isPseudoProbeDiscriminator(Discriminator)) { - auto Index = - PseudoProbeDwarfDiscriminator::extractProbeIndex(Discriminator); - auto Type = - PseudoProbeDwarfDiscriminator::extractProbeType(Discriminator); - auto Attr = PseudoProbeDwarfDiscriminator::extractProbeAttributes( - Discriminator); - // Round small factors to 0 to avoid over-counting. - uint32_t IntFactor = - PseudoProbeDwarfDiscriminator::FullDistributionFactor; - if (Factor < 1) - IntFactor *= Factor; - uint32_t V = PseudoProbeDwarfDiscriminator::packProbeData( - Index, Type, Attr, IntFactor); - DIL = DIL->cloneWithDiscriminator(V); - Inst.setDebugLoc(DIL); - } - } - } -} -} // namespace llvm +//===- PseudoProbe.cpp - Pseudo Probe Helpers -----------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file implements the helpers to manipulate pseudo probe IR intrinsic +// calls. +// +//===----------------------------------------------------------------------===// + +#include "llvm/IR/PseudoProbe.h" +#include "llvm/IR/DebugInfoMetadata.h" +#include "llvm/IR/IRBuilder.h" +#include "llvm/IR/Instruction.h" + +using namespace llvm; + +namespace llvm { + +Optional<PseudoProbe> extractProbeFromDiscriminator(const Instruction &Inst) { + assert(isa<CallBase>(&Inst) && !isa<IntrinsicInst>(&Inst) && + "Only call instructions should have pseudo probe encodes as their " + "Dwarf discriminators"); + if (const DebugLoc &DLoc = Inst.getDebugLoc()) { + const DILocation *DIL = DLoc; + auto Discriminator = DIL->getDiscriminator(); + if (DILocation::isPseudoProbeDiscriminator(Discriminator)) { + PseudoProbe Probe; + Probe.Id = + PseudoProbeDwarfDiscriminator::extractProbeIndex(Discriminator); + Probe.Type = + PseudoProbeDwarfDiscriminator::extractProbeType(Discriminator); + Probe.Attr = + PseudoProbeDwarfDiscriminator::extractProbeAttributes(Discriminator); + Probe.Factor = + PseudoProbeDwarfDiscriminator::extractProbeFactor(Discriminator) / + (float)PseudoProbeDwarfDiscriminator::FullDistributionFactor; + return Probe; + } + } + return None; +} + +Optional<PseudoProbe> extractProbe(const Instruction &Inst) { + if (const auto *II = dyn_cast<PseudoProbeInst>(&Inst)) { + PseudoProbe Probe; + Probe.Id = II->getIndex()->getZExtValue(); + Probe.Type = (uint32_t)PseudoProbeType::Block; + Probe.Attr = II->getAttributes()->getZExtValue(); + Probe.Factor = II->getFactor()->getZExtValue() / + (float)PseudoProbeFullDistributionFactor; + return Probe; + } + + if (isa<CallBase>(&Inst) && !isa<IntrinsicInst>(&Inst)) + return extractProbeFromDiscriminator(Inst); + + return None; +} + +void setProbeDistributionFactor(Instruction &Inst, float Factor) { + assert(Factor >= 0 && Factor <= 1 && + "Distribution factor must be in [0, 1.0]"); + if (auto *II = dyn_cast<PseudoProbeInst>(&Inst)) { + IRBuilder<> Builder(&Inst); + uint64_t IntFactor = PseudoProbeFullDistributionFactor; + if (Factor < 1) + IntFactor *= Factor; + auto OrigFactor = II->getFactor()->getZExtValue(); + if (IntFactor != OrigFactor) + II->replaceUsesOfWith(II->getFactor(), Builder.getInt64(IntFactor)); + } else if (isa<CallBase>(&Inst) && !isa<IntrinsicInst>(&Inst)) { + if (const DebugLoc &DLoc = Inst.getDebugLoc()) { + const DILocation *DIL = DLoc; + auto Discriminator = DIL->getDiscriminator(); + if (DILocation::isPseudoProbeDiscriminator(Discriminator)) { + auto Index = + PseudoProbeDwarfDiscriminator::extractProbeIndex(Discriminator); + auto Type = + PseudoProbeDwarfDiscriminator::extractProbeType(Discriminator); + auto Attr = PseudoProbeDwarfDiscriminator::extractProbeAttributes( + Discriminator); + // Round small factors to 0 to avoid over-counting. + uint32_t IntFactor = + PseudoProbeDwarfDiscriminator::FullDistributionFactor; + if (Factor < 1) + IntFactor *= Factor; + uint32_t V = PseudoProbeDwarfDiscriminator::packProbeData( + Index, Type, Attr, IntFactor); + DIL = DIL->cloneWithDiscriminator(V); + Inst.setDebugLoc(DIL); + } + } + } +} +} // namespace llvm diff --git a/contrib/libs/llvm12/lib/IR/ReplaceConstant.cpp b/contrib/libs/llvm12/lib/IR/ReplaceConstant.cpp index 7efa525d42..b06e838d60 100644 --- a/contrib/libs/llvm12/lib/IR/ReplaceConstant.cpp +++ b/contrib/libs/llvm12/lib/IR/ReplaceConstant.cpp @@ -1,70 +1,70 @@ -//===- ReplaceConstant.cpp - Replace LLVM constant expression--------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file implements a utility function for replacing LLVM constant -// expressions by instructions. -// -//===----------------------------------------------------------------------===// - -#include "llvm/IR/ReplaceConstant.h" -#include "llvm/IR/IRBuilder.h" -#include "llvm/IR/Instructions.h" -#include "llvm/IR/NoFolder.h" - -namespace llvm { -// Replace a constant expression by instructions with equivalent operations at -// a specified location. -Instruction *createReplacementInstr(ConstantExpr *CE, Instruction *Instr) { - IRBuilder<NoFolder> Builder(Instr); - unsigned OpCode = CE->getOpcode(); - switch (OpCode) { - case Instruction::GetElementPtr: { - SmallVector<Value *, 4> CEOpVec(CE->operands()); - ArrayRef<Value *> CEOps(CEOpVec); - return dyn_cast<Instruction>( - Builder.CreateInBoundsGEP(cast<GEPOperator>(CE)->getSourceElementType(), - CEOps[0], CEOps.slice(1))); - } - case Instruction::Add: - case Instruction::Sub: - case Instruction::Mul: - case Instruction::UDiv: - case Instruction::SDiv: - case Instruction::FDiv: - case Instruction::URem: - case Instruction::SRem: - case Instruction::FRem: - case Instruction::Shl: - case Instruction::LShr: - case Instruction::AShr: - case Instruction::And: - case Instruction::Or: - case Instruction::Xor: - return dyn_cast<Instruction>( - Builder.CreateBinOp((Instruction::BinaryOps)OpCode, CE->getOperand(0), - CE->getOperand(1), CE->getName())); - case Instruction::Trunc: - case Instruction::ZExt: - case Instruction::SExt: - case Instruction::FPToUI: - case Instruction::FPToSI: - case Instruction::UIToFP: - case Instruction::SIToFP: - case Instruction::FPTrunc: - case Instruction::FPExt: - case Instruction::PtrToInt: - case Instruction::IntToPtr: - case Instruction::BitCast: - return dyn_cast<Instruction>( - Builder.CreateCast((Instruction::CastOps)OpCode, CE->getOperand(0), - CE->getType(), CE->getName())); - default: - llvm_unreachable("Unhandled constant expression!\n"); - } -} -} // namespace llvm +//===- ReplaceConstant.cpp - Replace LLVM constant expression--------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file implements a utility function for replacing LLVM constant +// expressions by instructions. +// +//===----------------------------------------------------------------------===// + +#include "llvm/IR/ReplaceConstant.h" +#include "llvm/IR/IRBuilder.h" +#include "llvm/IR/Instructions.h" +#include "llvm/IR/NoFolder.h" + +namespace llvm { +// Replace a constant expression by instructions with equivalent operations at +// a specified location. +Instruction *createReplacementInstr(ConstantExpr *CE, Instruction *Instr) { + IRBuilder<NoFolder> Builder(Instr); + unsigned OpCode = CE->getOpcode(); + switch (OpCode) { + case Instruction::GetElementPtr: { + SmallVector<Value *, 4> CEOpVec(CE->operands()); + ArrayRef<Value *> CEOps(CEOpVec); + return dyn_cast<Instruction>( + Builder.CreateInBoundsGEP(cast<GEPOperator>(CE)->getSourceElementType(), + CEOps[0], CEOps.slice(1))); + } + case Instruction::Add: + case Instruction::Sub: + case Instruction::Mul: + case Instruction::UDiv: + case Instruction::SDiv: + case Instruction::FDiv: + case Instruction::URem: + case Instruction::SRem: + case Instruction::FRem: + case Instruction::Shl: + case Instruction::LShr: + case Instruction::AShr: + case Instruction::And: + case Instruction::Or: + case Instruction::Xor: + return dyn_cast<Instruction>( + Builder.CreateBinOp((Instruction::BinaryOps)OpCode, CE->getOperand(0), + CE->getOperand(1), CE->getName())); + case Instruction::Trunc: + case Instruction::ZExt: + case Instruction::SExt: + case Instruction::FPToUI: + case Instruction::FPToSI: + case Instruction::UIToFP: + case Instruction::SIToFP: + case Instruction::FPTrunc: + case Instruction::FPExt: + case Instruction::PtrToInt: + case Instruction::IntToPtr: + case Instruction::BitCast: + return dyn_cast<Instruction>( + Builder.CreateCast((Instruction::CastOps)OpCode, CE->getOperand(0), + CE->getType(), CE->getName())); + default: + llvm_unreachable("Unhandled constant expression!\n"); + } +} +} // namespace llvm diff --git a/contrib/libs/llvm12/lib/IR/SafepointIRVerifier.cpp b/contrib/libs/llvm12/lib/IR/SafepointIRVerifier.cpp index 8ed31b6668..444f714f8f 100644 --- a/contrib/libs/llvm12/lib/IR/SafepointIRVerifier.cpp +++ b/contrib/libs/llvm12/lib/IR/SafepointIRVerifier.cpp @@ -561,7 +561,7 @@ GCPtrTracker::GCPtrTracker(const Function &F, const DominatorTree &DT, } BasicBlockState *GCPtrTracker::getBasicBlockState(const BasicBlock *BB) { - return BlockMap.lookup(BB); + return BlockMap.lookup(BB); } const BasicBlockState *GCPtrTracker::getBasicBlockState( diff --git a/contrib/libs/llvm12/lib/IR/StructuralHash.cpp b/contrib/libs/llvm12/lib/IR/StructuralHash.cpp index 5a6e074513..cf8e7cb1d6 100644 --- a/contrib/libs/llvm12/lib/IR/StructuralHash.cpp +++ b/contrib/libs/llvm12/lib/IR/StructuralHash.cpp @@ -1,84 +1,84 @@ -//===-- StructuralHash.cpp - IR Hash for expensive checks -------*- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// - -#ifdef EXPENSIVE_CHECKS - -#include "llvm/IR/StructuralHash.h" -#include "llvm/IR/Function.h" -#include "llvm/IR/Module.h" - -using namespace llvm; - -namespace { -namespace details { - -// Basic hashing mechanism to detect structural change to the IR, used to verify -// pass return status consistency with actual change. Loosely copied from -// llvm/lib/Transforms/Utils/FunctionComparator.cpp - -class StructuralHash { - uint64_t Hash = 0x6acaa36bef8325c5ULL; - - void update(uint64_t V) { Hash = hashing::detail::hash_16_bytes(Hash, V); } - -public: - StructuralHash() = default; - - void update(const Function &F) { - if (F.empty()) - return; - - update(F.isVarArg()); - update(F.arg_size()); - - SmallVector<const BasicBlock *, 8> BBs; - SmallPtrSet<const BasicBlock *, 16> VisitedBBs; - - BBs.push_back(&F.getEntryBlock()); - VisitedBBs.insert(BBs[0]); - while (!BBs.empty()) { - const BasicBlock *BB = BBs.pop_back_val(); - update(45798); // Block header - for (auto &Inst : *BB) - update(Inst.getOpcode()); - - const Instruction *Term = BB->getTerminator(); - for (unsigned i = 0, e = Term->getNumSuccessors(); i != e; ++i) { - if (!VisitedBBs.insert(Term->getSuccessor(i)).second) - continue; - BBs.push_back(Term->getSuccessor(i)); - } - } - } - - void update(const Module &M) { - for (const Function &F : M) - update(F); - } - - uint64_t getHash() const { return Hash; } -}; - -} // namespace details - -} // namespace - -uint64_t llvm::StructuralHash(const Function &F) { - details::StructuralHash H; - H.update(F); - return H.getHash(); -} - -uint64_t llvm::StructuralHash(const Module &M) { - details::StructuralHash H; - H.update(M); - return H.getHash(); -} - -#endif +//===-- StructuralHash.cpp - IR Hash for expensive checks -------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// + +#ifdef EXPENSIVE_CHECKS + +#include "llvm/IR/StructuralHash.h" +#include "llvm/IR/Function.h" +#include "llvm/IR/Module.h" + +using namespace llvm; + +namespace { +namespace details { + +// Basic hashing mechanism to detect structural change to the IR, used to verify +// pass return status consistency with actual change. Loosely copied from +// llvm/lib/Transforms/Utils/FunctionComparator.cpp + +class StructuralHash { + uint64_t Hash = 0x6acaa36bef8325c5ULL; + + void update(uint64_t V) { Hash = hashing::detail::hash_16_bytes(Hash, V); } + +public: + StructuralHash() = default; + + void update(const Function &F) { + if (F.empty()) + return; + + update(F.isVarArg()); + update(F.arg_size()); + + SmallVector<const BasicBlock *, 8> BBs; + SmallPtrSet<const BasicBlock *, 16> VisitedBBs; + + BBs.push_back(&F.getEntryBlock()); + VisitedBBs.insert(BBs[0]); + while (!BBs.empty()) { + const BasicBlock *BB = BBs.pop_back_val(); + update(45798); // Block header + for (auto &Inst : *BB) + update(Inst.getOpcode()); + + const Instruction *Term = BB->getTerminator(); + for (unsigned i = 0, e = Term->getNumSuccessors(); i != e; ++i) { + if (!VisitedBBs.insert(Term->getSuccessor(i)).second) + continue; + BBs.push_back(Term->getSuccessor(i)); + } + } + } + + void update(const Module &M) { + for (const Function &F : M) + update(F); + } + + uint64_t getHash() const { return Hash; } +}; + +} // namespace details + +} // namespace + +uint64_t llvm::StructuralHash(const Function &F) { + details::StructuralHash H; + H.update(F); + return H.getHash(); +} + +uint64_t llvm::StructuralHash(const Module &M) { + details::StructuralHash H; + H.update(M); + return H.getHash(); +} + +#endif diff --git a/contrib/libs/llvm12/lib/IR/Type.cpp b/contrib/libs/llvm12/lib/IR/Type.cpp index bade7dc325..13a6e116c3 100644 --- a/contrib/libs/llvm12/lib/IR/Type.cpp +++ b/contrib/libs/llvm12/lib/IR/Type.cpp @@ -49,7 +49,7 @@ Type *Type::getPrimitiveType(LLVMContext &C, TypeID IDNumber) { case LabelTyID : return getLabelTy(C); case MetadataTyID : return getMetadataTy(C); case X86_MMXTyID : return getX86_MMXTy(C); - case X86_AMXTyID : return getX86_AMXTy(C); + case X86_AMXTyID : return getX86_AMXTy(C); case TokenTyID : return getTokenTy(C); default: return nullptr; @@ -82,14 +82,14 @@ bool Type::canLosslesslyBitCastTo(Type *Ty) const { Ty->getPrimitiveSizeInBits().getFixedSize() == 64) return true; - // 8192-bit fixed width vector types can be losslessly converted to x86amx. - if (((isa<FixedVectorType>(this)) && Ty->isX86_AMXTy()) && - getPrimitiveSizeInBits().getFixedSize() == 8192) - return true; - if ((isX86_AMXTy() && isa<FixedVectorType>(Ty)) && - Ty->getPrimitiveSizeInBits().getFixedSize() == 8192) - return true; - + // 8192-bit fixed width vector types can be losslessly converted to x86amx. + if (((isa<FixedVectorType>(this)) && Ty->isX86_AMXTy()) && + getPrimitiveSizeInBits().getFixedSize() == 8192) + return true; + if ((isX86_AMXTy() && isa<FixedVectorType>(Ty)) && + Ty->getPrimitiveSizeInBits().getFixedSize() == 8192) + return true; + // At this point we have only various mismatches of the first class types // remaining and ptr->ptr. Just select the lossless conversions. Everything // else is not lossless. Conservatively assume we can't losslessly convert @@ -129,7 +129,7 @@ TypeSize Type::getPrimitiveSizeInBits() const { case Type::FP128TyID: return TypeSize::Fixed(128); case Type::PPC_FP128TyID: return TypeSize::Fixed(128); case Type::X86_MMXTyID: return TypeSize::Fixed(64); - case Type::X86_AMXTyID: return TypeSize::Fixed(8192); + case Type::X86_AMXTyID: return TypeSize::Fixed(8192); case Type::IntegerTyID: return TypeSize::Fixed(cast<IntegerType>(this)->getBitWidth()); case Type::FixedVectorTyID: @@ -138,7 +138,7 @@ TypeSize Type::getPrimitiveSizeInBits() const { ElementCount EC = VTy->getElementCount(); TypeSize ETS = VTy->getElementType()->getPrimitiveSizeInBits(); assert(!ETS.isScalable() && "Vector type should have fixed-width elements"); - return {ETS.getFixedSize() * EC.getKnownMinValue(), EC.isScalable()}; + return {ETS.getFixedSize() * EC.getKnownMinValue(), EC.isScalable()}; } default: return TypeSize::Fixed(0); } @@ -189,7 +189,7 @@ Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; } Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; } Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; } Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; } -Type *Type::getX86_AMXTy(LLVMContext &C) { return &C.pImpl->X86_AMXTy; } +Type *Type::getX86_AMXTy(LLVMContext &C) { return &C.pImpl->X86_AMXTy; } IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; } IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; } @@ -234,10 +234,10 @@ PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) { return getX86_MMXTy(C)->getPointerTo(AS); } -PointerType *Type::getX86_AMXPtrTy(LLVMContext &C, unsigned AS) { - return getX86_AMXTy(C)->getPointerTo(AS); -} - +PointerType *Type::getX86_AMXPtrTy(LLVMContext &C, unsigned AS) { + return getX86_AMXTy(C)->getPointerTo(AS); +} + PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) { return getIntNTy(C, N)->getPointerTo(AS); } @@ -390,18 +390,18 @@ StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes, return ST; } -bool StructType::containsScalableVectorType() const { - for (Type *Ty : elements()) { - if (isa<ScalableVectorType>(Ty)) - return true; - if (auto *STy = dyn_cast<StructType>(Ty)) - if (STy->containsScalableVectorType()) - return true; - } - - return false; -} - +bool StructType::containsScalableVectorType() const { + for (Type *Ty : elements()) { + if (isa<ScalableVectorType>(Ty)) + return true; + if (auto *STy = dyn_cast<StructType>(Ty)) + if (STy->containsScalableVectorType()) + return true; + } + + return false; +} + void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) { assert(isOpaque() && "Struct body already set!"); @@ -521,14 +521,14 @@ bool StructType::isSized(SmallPtrSetImpl<Type*> *Visited) const { // Okay, our struct is sized if all of the elements are, but if one of the // elements is opaque, the struct isn't sized *yet*, but may become sized in // the future, so just bail out without caching. - for (Type *Ty : elements()) { - // If the struct contains a scalable vector type, don't consider it sized. - // This prevents it from being used in loads/stores/allocas/GEPs. - if (isa<ScalableVectorType>(Ty)) - return false; - if (!Ty->isSized(Visited)) + for (Type *Ty : elements()) { + // If the struct contains a scalable vector type, don't consider it sized. + // This prevents it from being used in loads/stores/allocas/GEPs. + if (isa<ScalableVectorType>(Ty)) return false; - } + if (!Ty->isSized(Visited)) + return false; + } // Here we cheat a bit and cast away const-ness. The goal is to memoize when // we find a sized type, as types can only move from opaque to sized, not the @@ -548,7 +548,7 @@ StringRef StructType::getName() const { bool StructType::isValidElementType(Type *ElemTy) { return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() && !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() && - !ElemTy->isTokenTy(); + !ElemTy->isTokenTy(); } bool StructType::isLayoutIdentical(StructType *Other) const { @@ -580,10 +580,10 @@ bool StructType::indexValid(const Value *V) const { return CU && CU->getZExtValue() < getNumElements(); } -StructType *StructType::getTypeByName(LLVMContext &C, StringRef Name) { - return C.pImpl->NamedStructTypes.lookup(Name); -} - +StructType *StructType::getTypeByName(LLVMContext &C, StringRef Name) { + return C.pImpl->NamedStructTypes.lookup(Name); +} + //===----------------------------------------------------------------------===// // ArrayType Implementation //===----------------------------------------------------------------------===// @@ -625,10 +625,10 @@ VectorType::VectorType(Type *ElType, unsigned EQ, Type::TypeID TID) } VectorType *VectorType::get(Type *ElementType, ElementCount EC) { - if (EC.isScalable()) - return ScalableVectorType::get(ElementType, EC.getKnownMinValue()); + if (EC.isScalable()) + return ScalableVectorType::get(ElementType, EC.getKnownMinValue()); else - return FixedVectorType::get(ElementType, EC.getKnownMinValue()); + return FixedVectorType::get(ElementType, EC.getKnownMinValue()); } bool VectorType::isValidElementType(Type *ElemTy) { @@ -646,7 +646,7 @@ FixedVectorType *FixedVectorType::get(Type *ElementType, unsigned NumElts) { "be an integer, floating point, or " "pointer type."); - auto EC = ElementCount::getFixed(NumElts); + auto EC = ElementCount::getFixed(NumElts); LLVMContextImpl *pImpl = ElementType->getContext().pImpl; VectorType *&Entry = ElementType->getContext() @@ -668,7 +668,7 @@ ScalableVectorType *ScalableVectorType::get(Type *ElementType, "be an integer, floating point, or " "pointer type."); - auto EC = ElementCount::getScalable(MinNumElts); + auto EC = ElementCount::getScalable(MinNumElts); LLVMContextImpl *pImpl = ElementType->getContext().pImpl; VectorType *&Entry = ElementType->getContext() diff --git a/contrib/libs/llvm12/lib/IR/Use.cpp b/contrib/libs/llvm12/lib/IR/Use.cpp index 99049c0232..7e326871f6 100644 --- a/contrib/libs/llvm12/lib/IR/Use.cpp +++ b/contrib/libs/llvm12/lib/IR/Use.cpp @@ -17,17 +17,17 @@ void Use::swap(Use &RHS) { if (Val == RHS.Val) return; - std::swap(Val, RHS.Val); - std::swap(Next, RHS.Next); - std::swap(Prev, RHS.Prev); + std::swap(Val, RHS.Val); + std::swap(Next, RHS.Next); + std::swap(Prev, RHS.Prev); - *Prev = this; - if (Next) - Next->Prev = &Next; + *Prev = this; + if (Next) + Next->Prev = &Next; - *RHS.Prev = &RHS; - if (RHS.Next) - RHS.Next->Prev = &RHS.Next; + *RHS.Prev = &RHS; + if (RHS.Next) + RHS.Next->Prev = &RHS.Next; } unsigned Use::getOperandNo() const { diff --git a/contrib/libs/llvm12/lib/IR/User.cpp b/contrib/libs/llvm12/lib/IR/User.cpp index 9105c6fbd2..e5f77136ac 100644 --- a/contrib/libs/llvm12/lib/IR/User.cpp +++ b/contrib/libs/llvm12/lib/IR/User.cpp @@ -29,7 +29,7 @@ void User::replaceUsesOfWith(Value *From, Value *To) { // The side effects of this setOperand call include linking to // "To", adding "this" to the uses list of To, and // most importantly, removing "this" from the use list of "From". - setOperand(i, To); + setOperand(i, To); } } diff --git a/contrib/libs/llvm12/lib/IR/Value.cpp b/contrib/libs/llvm12/lib/IR/Value.cpp index 572f37a324..6f1256b4c7 100644 --- a/contrib/libs/llvm12/lib/IR/Value.cpp +++ b/contrib/libs/llvm12/lib/IR/Value.cpp @@ -51,9 +51,9 @@ static inline Type *checkType(Type *Ty) { } Value::Value(Type *ty, unsigned scid) - : VTy(checkType(ty)), UseList(nullptr), SubclassID(scid), HasValueHandle(0), - SubclassOptionalData(0), SubclassData(0), NumUserOperands(0), - IsUsedByMD(false), HasName(false), HasMetadata(false) { + : VTy(checkType(ty)), UseList(nullptr), SubclassID(scid), HasValueHandle(0), + SubclassOptionalData(0), SubclassData(0), NumUserOperands(0), + IsUsedByMD(false), HasName(false), HasMetadata(false) { static_assert(ConstantFirstVal == 0, "!(SubclassID < ConstantFirstVal)"); // FIXME: Why isn't this in the subclass gunk?? // Note, we cannot call isa<CallInst> before the CallInst has been @@ -77,10 +77,10 @@ Value::~Value() { if (isUsedByMetadata()) ValueAsMetadata::handleDeletion(this); - // Remove associated metadata from context. - if (HasMetadata) - clearMetadata(); - + // Remove associated metadata from context. + if (HasMetadata) + clearMetadata(); + #ifndef NDEBUG // Only in -g mode... // Check to make sure that there are no uses of this value that are still // around when the value is destroyed. If there are, then we have a dangling @@ -151,14 +151,14 @@ bool Value::hasNUsesOrMore(unsigned N) const { return hasNItemsOrMore(use_begin(), use_end(), N); } -bool Value::hasOneUser() const { - if (use_empty()) - return false; - if (hasOneUse()) - return true; - return std::equal(++user_begin(), user_end(), user_begin()); -} - +bool Value::hasOneUser() const { + if (use_empty()) + return false; + if (hasOneUse()) + return true; + return std::equal(++user_begin(), user_end(), user_begin()); +} + static bool isUnDroppableUser(const User *U) { return !U->isDroppable(); } Use *Value::getSingleUndroppableUse() { @@ -187,36 +187,36 @@ void Value::dropDroppableUses( for (Use &U : uses()) if (U.getUser()->isDroppable() && ShouldDrop(&U)) ToBeEdited.push_back(&U); - for (Use *U : ToBeEdited) - dropDroppableUse(*U); -} - -void Value::dropDroppableUsesIn(User &Usr) { - assert(Usr.isDroppable() && "Expected a droppable user!"); - for (Use &UsrOp : Usr.operands()) { - if (UsrOp.get() == this) - dropDroppableUse(UsrOp); + for (Use *U : ToBeEdited) + dropDroppableUse(*U); +} + +void Value::dropDroppableUsesIn(User &Usr) { + assert(Usr.isDroppable() && "Expected a droppable user!"); + for (Use &UsrOp : Usr.operands()) { + if (UsrOp.get() == this) + dropDroppableUse(UsrOp); } } -void Value::dropDroppableUse(Use &U) { - U.removeFromList(); - if (auto *Assume = dyn_cast<IntrinsicInst>(U.getUser())) { - assert(Assume->getIntrinsicID() == Intrinsic::assume); - unsigned OpNo = U.getOperandNo(); - if (OpNo == 0) - U.set(ConstantInt::getTrue(Assume->getContext())); - else { - U.set(UndefValue::get(U.get()->getType())); - CallInst::BundleOpInfo &BOI = Assume->getBundleOpInfoForOperand(OpNo); - BOI.Tag = Assume->getContext().pImpl->getOrInsertBundleTag("ignore"); - } - return; - } - - llvm_unreachable("unkown droppable use"); -} - +void Value::dropDroppableUse(Use &U) { + U.removeFromList(); + if (auto *Assume = dyn_cast<IntrinsicInst>(U.getUser())) { + assert(Assume->getIntrinsicID() == Intrinsic::assume); + unsigned OpNo = U.getOperandNo(); + if (OpNo == 0) + U.set(ConstantInt::getTrue(Assume->getContext())); + else { + U.set(UndefValue::get(U.get()->getType())); + CallInst::BundleOpInfo &BOI = Assume->getBundleOpInfoForOperand(OpNo); + BOI.Tag = Assume->getContext().pImpl->getOrInsertBundleTag("ignore"); + } + return; + } + + llvm_unreachable("unkown droppable use"); +} + bool Value::isUsedInBasicBlock(const BasicBlock *BB) const { // This can be computed either by scanning the instructions in BB, or by // scanning the use list of this Value. Both lists can be very long, but @@ -430,18 +430,18 @@ void Value::takeName(Value *V) { ST->reinsertValue(this); } -#ifndef NDEBUG -std::string Value::getNameOrAsOperand() const { - if (!getName().empty()) - return std::string(getName()); - - std::string BBName; - raw_string_ostream OS(BBName); - printAsOperand(OS, false); - return OS.str(); -} -#endif - +#ifndef NDEBUG +std::string Value::getNameOrAsOperand() const { + if (!getName().empty()) + return std::string(getName()); + + std::string BBName; + raw_string_ostream OS(BBName); + printAsOperand(OS, false); + return OS.str(); +} +#endif + void Value::assertModuleIsMaterializedImpl() const { #ifndef NDEBUG const GlobalValue *GV = dyn_cast<GlobalValue>(this); @@ -728,16 +728,16 @@ uint64_t Value::getPointerDereferenceableBytes(const DataLayout &DL, CanBeNull = false; if (const Argument *A = dyn_cast<Argument>(this)) { DerefBytes = A->getDereferenceableBytes(); - if (DerefBytes == 0) { - // Handle byval/byref/inalloca/preallocated arguments - if (Type *ArgMemTy = A->getPointeeInMemoryValueType()) { - if (ArgMemTy->isSized()) { - // FIXME: Why isn't this the type alloc size? - DerefBytes = DL.getTypeStoreSize(ArgMemTy).getKnownMinSize(); - } - } + if (DerefBytes == 0) { + // Handle byval/byref/inalloca/preallocated arguments + if (Type *ArgMemTy = A->getPointeeInMemoryValueType()) { + if (ArgMemTy->isSized()) { + // FIXME: Why isn't this the type alloc size? + DerefBytes = DL.getTypeStoreSize(ArgMemTy).getKnownMinSize(); + } + } } - + if (DerefBytes == 0) { DerefBytes = A->getDereferenceableOrNullBytes(); CanBeNull = true; @@ -825,7 +825,7 @@ Align Value::getPointerAlignment(const DataLayout &DL) const { const MaybeAlign Alignment = A->getParamAlign(); if (!Alignment && A->hasStructRetAttr()) { // An sret parameter has at least the ABI alignment of the return type. - Type *EltTy = A->getParamStructRetType(); + Type *EltTy = A->getParamStructRetType(); if (EltTy->isSized()) return DL.getABITypeAlign(EltTy); } diff --git a/contrib/libs/llvm12/lib/IR/Verifier.cpp b/contrib/libs/llvm12/lib/IR/Verifier.cpp index 6dd299ee98..71152f7176 100644 --- a/contrib/libs/llvm12/lib/IR/Verifier.cpp +++ b/contrib/libs/llvm12/lib/IR/Verifier.cpp @@ -115,11 +115,11 @@ using namespace llvm; -static cl::opt<bool> VerifyNoAliasScopeDomination( - "verify-noalias-scope-decl-dom", cl::Hidden, cl::init(false), - cl::desc("Ensure that llvm.experimental.noalias.scope.decl for identical " - "scopes are not dominating")); - +static cl::opt<bool> VerifyNoAliasScopeDomination( + "verify-noalias-scope-decl-dom", cl::Hidden, cl::init(false), + cl::desc("Ensure that llvm.experimental.noalias.scope.decl for identical " + "scopes are not dominating")); + namespace llvm { struct VerifierSupport { @@ -287,9 +287,9 @@ class Verifier : public InstVisitor<Verifier>, VerifierSupport { /// Whether the current function has a DISubprogram attached to it. bool HasDebugInfo = false; - /// The current source language. - dwarf::SourceLanguage CurrentSourceLang = dwarf::DW_LANG_lo_user; - + /// The current source language. + dwarf::SourceLanguage CurrentSourceLang = dwarf::DW_LANG_lo_user; + /// Whether source was present on the first DIFile encountered in each CU. DenseMap<const DICompileUnit *, bool> HasSourceDebugInfo; @@ -318,8 +318,8 @@ class Verifier : public InstVisitor<Verifier>, VerifierSupport { TBAAVerifier TBAAVerifyHelper; - SmallVector<IntrinsicInst *, 4> NoAliasScopeDecls; - + SmallVector<IntrinsicInst *, 4> NoAliasScopeDecls; + void checkAtomicMemAccessSize(Type *Ty, const Instruction *I); public: @@ -367,8 +367,8 @@ public: LandingPadResultTy = nullptr; SawFrameEscape = false; SiblingFuncletInfo.clear(); - verifyNoAliasScopeDecl(); - NoAliasScopeDecls.clear(); + verifyNoAliasScopeDecl(); + NoAliasScopeDecls.clear(); return !Broken; } @@ -436,7 +436,7 @@ private: void visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty); void visitDereferenceableMetadata(Instruction &I, MDNode *MD); void visitProfMetadata(Instruction &I, MDNode *MD); - void visitAnnotationMetadata(MDNode *Annotation); + void visitAnnotationMetadata(MDNode *Annotation); template <class Ty> bool isValidMetadataArray(const MDTuple &N); #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N); @@ -545,9 +545,9 @@ private: /// Verify all-or-nothing property of DIFile source attribute within a CU. void verifySourceDebugInfo(const DICompileUnit &U, const DIFile &F); - - /// Verify the llvm.experimental.noalias.scope.decl declarations - void verifyNoAliasScopeDecl(); + + /// Verify the llvm.experimental.noalias.scope.decl declarations + void verifyNoAliasScopeDecl(); }; } // end anonymous namespace @@ -603,8 +603,8 @@ void Verifier::visitGlobalValue(const GlobalValue &GV) { Assert(!GV.isDSOLocal(), "GlobalValue with DLLImport Storage is dso_local!", &GV); - Assert((GV.isDeclaration() && - (GV.hasExternalLinkage() || GV.hasExternalWeakLinkage())) || + Assert((GV.isDeclaration() && + (GV.hasExternalLinkage() || GV.hasExternalWeakLinkage())) || GV.hasAvailableExternallyLinkage(), "Global is marked as dllimport, but not external", &GV); } @@ -714,16 +714,16 @@ void Verifier::visitGlobalVariable(const GlobalVariable &GV) { } // Scalable vectors cannot be global variables, since we don't know - // the runtime size. If the global is an array containing scalable vectors, - // that will be caught by the isValidElementType methods in StructType or - // ArrayType instead. + // the runtime size. If the global is an array containing scalable vectors, + // that will be caught by the isValidElementType methods in StructType or + // ArrayType instead. Assert(!isa<ScalableVectorType>(GV.getValueType()), "Globals cannot contain scalable vectors", &GV); - if (auto *STy = dyn_cast<StructType>(GV.getValueType())) - Assert(!STy->containsScalableVectorType(), - "Globals cannot contain scalable vectors", &GV); - + if (auto *STy = dyn_cast<StructType>(GV.getValueType())) + Assert(!STy->containsScalableVectorType(), + "Globals cannot contain scalable vectors", &GV); + if (!GV.hasInitializer()) { visitGlobalValue(GV); return; @@ -913,9 +913,9 @@ void Verifier::visitDIScope(const DIScope &N) { void Verifier::visitDISubrange(const DISubrange &N) { AssertDI(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N); - bool HasAssumedSizedArraySupport = dwarf::isFortran(CurrentSourceLang); - AssertDI(HasAssumedSizedArraySupport || N.getRawCountNode() || - N.getRawUpperBound(), + bool HasAssumedSizedArraySupport = dwarf::isFortran(CurrentSourceLang); + AssertDI(HasAssumedSizedArraySupport || N.getRawCountNode() || + N.getRawUpperBound(), "Subrange must contain count or upperBound", &N); AssertDI(!N.getRawCountNode() || !N.getRawUpperBound(), "Subrange can have any one of count or upperBound", &N); @@ -941,43 +941,43 @@ void Verifier::visitDISubrange(const DISubrange &N) { "Stride must be signed constant or DIVariable or DIExpression", &N); } -void Verifier::visitDIGenericSubrange(const DIGenericSubrange &N) { - AssertDI(N.getTag() == dwarf::DW_TAG_generic_subrange, "invalid tag", &N); - AssertDI(N.getRawCountNode() || N.getRawUpperBound(), - "GenericSubrange must contain count or upperBound", &N); - AssertDI(!N.getRawCountNode() || !N.getRawUpperBound(), - "GenericSubrange can have any one of count or upperBound", &N); - auto *CBound = N.getRawCountNode(); - AssertDI(!CBound || isa<DIVariable>(CBound) || isa<DIExpression>(CBound), - "Count must be signed constant or DIVariable or DIExpression", &N); - auto *LBound = N.getRawLowerBound(); - AssertDI(LBound, "GenericSubrange must contain lowerBound", &N); - AssertDI(isa<DIVariable>(LBound) || isa<DIExpression>(LBound), - "LowerBound must be signed constant or DIVariable or DIExpression", - &N); - auto *UBound = N.getRawUpperBound(); - AssertDI(!UBound || isa<DIVariable>(UBound) || isa<DIExpression>(UBound), - "UpperBound must be signed constant or DIVariable or DIExpression", - &N); - auto *Stride = N.getRawStride(); - AssertDI(Stride, "GenericSubrange must contain stride", &N); - AssertDI(isa<DIVariable>(Stride) || isa<DIExpression>(Stride), - "Stride must be signed constant or DIVariable or DIExpression", &N); -} - +void Verifier::visitDIGenericSubrange(const DIGenericSubrange &N) { + AssertDI(N.getTag() == dwarf::DW_TAG_generic_subrange, "invalid tag", &N); + AssertDI(N.getRawCountNode() || N.getRawUpperBound(), + "GenericSubrange must contain count or upperBound", &N); + AssertDI(!N.getRawCountNode() || !N.getRawUpperBound(), + "GenericSubrange can have any one of count or upperBound", &N); + auto *CBound = N.getRawCountNode(); + AssertDI(!CBound || isa<DIVariable>(CBound) || isa<DIExpression>(CBound), + "Count must be signed constant or DIVariable or DIExpression", &N); + auto *LBound = N.getRawLowerBound(); + AssertDI(LBound, "GenericSubrange must contain lowerBound", &N); + AssertDI(isa<DIVariable>(LBound) || isa<DIExpression>(LBound), + "LowerBound must be signed constant or DIVariable or DIExpression", + &N); + auto *UBound = N.getRawUpperBound(); + AssertDI(!UBound || isa<DIVariable>(UBound) || isa<DIExpression>(UBound), + "UpperBound must be signed constant or DIVariable or DIExpression", + &N); + auto *Stride = N.getRawStride(); + AssertDI(Stride, "GenericSubrange must contain stride", &N); + AssertDI(isa<DIVariable>(Stride) || isa<DIExpression>(Stride), + "Stride must be signed constant or DIVariable or DIExpression", &N); +} + void Verifier::visitDIEnumerator(const DIEnumerator &N) { AssertDI(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N); } void Verifier::visitDIBasicType(const DIBasicType &N) { AssertDI(N.getTag() == dwarf::DW_TAG_base_type || - N.getTag() == dwarf::DW_TAG_unspecified_type || - N.getTag() == dwarf::DW_TAG_string_type, + N.getTag() == dwarf::DW_TAG_unspecified_type || + N.getTag() == dwarf::DW_TAG_string_type, "invalid tag", &N); -} - -void Verifier::visitDIStringType(const DIStringType &N) { - AssertDI(N.getTag() == dwarf::DW_TAG_string_type, "invalid tag", &N); +} + +void Verifier::visitDIStringType(const DIStringType &N) { + AssertDI(N.getTag() == dwarf::DW_TAG_string_type, "invalid tag", &N); AssertDI(!(N.isBigEndian() && N.isLittleEndian()) , "has conflicting flags", &N); } @@ -1079,21 +1079,21 @@ void Verifier::visitDICompositeType(const DICompositeType &N) { AssertDI(N.getTag() == dwarf::DW_TAG_array_type, "dataLocation can only appear in array type"); } - - if (N.getRawAssociated()) { - AssertDI(N.getTag() == dwarf::DW_TAG_array_type, - "associated can only appear in array type"); - } - - if (N.getRawAllocated()) { - AssertDI(N.getTag() == dwarf::DW_TAG_array_type, - "allocated can only appear in array type"); - } - - if (N.getRawRank()) { - AssertDI(N.getTag() == dwarf::DW_TAG_array_type, - "rank can only appear in array type"); - } + + if (N.getRawAssociated()) { + AssertDI(N.getTag() == dwarf::DW_TAG_array_type, + "associated can only appear in array type"); + } + + if (N.getRawAllocated()) { + AssertDI(N.getTag() == dwarf::DW_TAG_array_type, + "allocated can only appear in array type"); + } + + if (N.getRawRank()) { + AssertDI(N.getTag() == dwarf::DW_TAG_array_type, + "rank can only appear in array type"); + } } void Verifier::visitDISubroutineType(const DISubroutineType &N) { @@ -1143,8 +1143,8 @@ void Verifier::visitDICompileUnit(const DICompileUnit &N) { AssertDI(!N.getFile()->getFilename().empty(), "invalid filename", &N, N.getFile()); - CurrentSourceLang = (dwarf::SourceLanguage)N.getSourceLanguage(); - + CurrentSourceLang = (dwarf::SourceLanguage)N.getSourceLanguage(); + verifySourceDebugInfo(N, *N.getFile()); AssertDI((N.getEmissionKind() <= DICompileUnit::LastEmissionKind), @@ -1586,8 +1586,8 @@ void Verifier::visitModuleFlagCGProfileEntry(const MDOperand &MDO) { if (!FuncMDO) return; auto F = dyn_cast<ValueAsMetadata>(FuncMDO); - Assert(F && isa<Function>(F->getValue()->stripPointerCasts()), - "expected a Function or null", FuncMDO); + Assert(F && isa<Function>(F->getValue()->stripPointerCasts()), + "expected a Function or null", FuncMDO); }; auto Node = dyn_cast_or_null<MDNode>(MDO); Assert(Node && Node->getNumOperands() == 3, "expected a MDNode triple", MDO); @@ -1605,7 +1605,7 @@ static bool isFuncOnlyAttr(Attribute::AttrKind Kind) { case Attribute::NoReturn: case Attribute::NoSync: case Attribute::WillReturn: - case Attribute::NoCallback: + case Attribute::NoCallback: case Attribute::NoCfCheck: case Attribute::NoUnwind: case Attribute::NoInline: @@ -1634,7 +1634,7 @@ static bool isFuncOnlyAttr(Attribute::AttrKind Kind) { case Attribute::Builtin: case Attribute::NoBuiltin: case Attribute::Cold: - case Attribute::Hot: + case Attribute::Hot: case Attribute::OptForFuzzing: case Attribute::OptimizeNone: case Attribute::JumpTable: @@ -1648,8 +1648,8 @@ static bool isFuncOnlyAttr(Attribute::AttrKind Kind) { case Attribute::Speculatable: case Attribute::StrictFP: case Attribute::NullPointerIsValid: - case Attribute::MustProgress: - case Attribute::NoProfile: + case Attribute::MustProgress: + case Attribute::NoProfile: return true; default: break; @@ -1717,10 +1717,10 @@ void Verifier::verifyParameterAttrs(AttributeSet Attrs, Type *Ty, AttrCount += Attrs.hasAttribute(Attribute::StructRet) || Attrs.hasAttribute(Attribute::InReg); AttrCount += Attrs.hasAttribute(Attribute::Nest); - AttrCount += Attrs.hasAttribute(Attribute::ByRef); + AttrCount += Attrs.hasAttribute(Attribute::ByRef); Assert(AttrCount <= 1, "Attributes 'byval', 'inalloca', 'preallocated', 'inreg', 'nest', " - "'byref', and 'sret' are incompatible!", + "'byref', and 'sret' are incompatible!", V); Assert(!(Attrs.hasAttribute(Attribute::InAlloca) && @@ -1775,10 +1775,10 @@ void Verifier::verifyParameterAttrs(AttributeSet Attrs, Type *Ty, SmallPtrSet<Type*, 4> Visited; if (!PTy->getElementType()->isSized(&Visited)) { Assert(!Attrs.hasAttribute(Attribute::ByVal) && - !Attrs.hasAttribute(Attribute::ByRef) && - !Attrs.hasAttribute(Attribute::InAlloca) && - !Attrs.hasAttribute(Attribute::Preallocated), - "Attributes 'byval', 'byref', 'inalloca', and 'preallocated' do not " + !Attrs.hasAttribute(Attribute::ByRef) && + !Attrs.hasAttribute(Attribute::InAlloca) && + !Attrs.hasAttribute(Attribute::Preallocated), + "Attributes 'byval', 'byref', 'inalloca', and 'preallocated' do not " "support unsized types!", V); } @@ -1787,28 +1787,28 @@ void Verifier::verifyParameterAttrs(AttributeSet Attrs, Type *Ty, "Attribute 'swifterror' only applies to parameters " "with pointer to pointer type!", V); - - if (Attrs.hasAttribute(Attribute::ByRef)) { - Assert(Attrs.getByRefType() == PTy->getElementType(), - "Attribute 'byref' type does not match parameter!", V); - } - - if (Attrs.hasAttribute(Attribute::ByVal) && Attrs.getByValType()) { - Assert(Attrs.getByValType() == PTy->getElementType(), - "Attribute 'byval' type does not match parameter!", V); - } - - if (Attrs.hasAttribute(Attribute::Preallocated)) { - Assert(Attrs.getPreallocatedType() == PTy->getElementType(), - "Attribute 'preallocated' type does not match parameter!", V); - } + + if (Attrs.hasAttribute(Attribute::ByRef)) { + Assert(Attrs.getByRefType() == PTy->getElementType(), + "Attribute 'byref' type does not match parameter!", V); + } + + if (Attrs.hasAttribute(Attribute::ByVal) && Attrs.getByValType()) { + Assert(Attrs.getByValType() == PTy->getElementType(), + "Attribute 'byval' type does not match parameter!", V); + } + + if (Attrs.hasAttribute(Attribute::Preallocated)) { + Assert(Attrs.getPreallocatedType() == PTy->getElementType(), + "Attribute 'preallocated' type does not match parameter!", V); + } } else { Assert(!Attrs.hasAttribute(Attribute::ByVal), "Attribute 'byval' only applies to parameters with pointer type!", V); - Assert(!Attrs.hasAttribute(Attribute::ByRef), - "Attribute 'byref' only applies to parameters with pointer type!", - V); + Assert(!Attrs.hasAttribute(Attribute::ByRef), + "Attribute 'byref' only applies to parameters with pointer type!", + V); Assert(!Attrs.hasAttribute(Attribute::SwiftError), "Attribute 'swifterror' only applies to parameters " "with pointer type!", @@ -1839,11 +1839,11 @@ void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs, !RetAttrs.hasAttribute(Attribute::Returned) && !RetAttrs.hasAttribute(Attribute::InAlloca) && !RetAttrs.hasAttribute(Attribute::Preallocated) && - !RetAttrs.hasAttribute(Attribute::ByRef) && + !RetAttrs.hasAttribute(Attribute::ByRef) && !RetAttrs.hasAttribute(Attribute::SwiftSelf) && !RetAttrs.hasAttribute(Attribute::SwiftError)), - "Attributes 'byval', 'inalloca', 'preallocated', 'byref', " - "'nest', 'sret', 'nocapture', 'nofree', " + "Attributes 'byval', 'inalloca', 'preallocated', 'byref', " + "'nest', 'sret', 'nocapture', 'nofree', " "'returned', 'swiftself', and 'swifterror' do not apply to return " "values!", V); @@ -2177,8 +2177,8 @@ void Verifier::verifyStatepoint(const CallBase &Call) { Call); const int NumTransitionArgs = cast<ConstantInt>(NumTransitionArgsV)->getZExtValue(); - Assert(NumTransitionArgs == 0, - "gc.statepoint w/inline transition bundle is deprecated", Call); + Assert(NumTransitionArgs == 0, + "gc.statepoint w/inline transition bundle is deprecated", Call); const int EndTransitionArgsInx = EndCallArgsInx + 1 + NumTransitionArgs; const Value *NumDeoptArgsV = Call.getArgOperand(EndTransitionArgsInx + 1); @@ -2187,12 +2187,12 @@ void Verifier::verifyStatepoint(const CallBase &Call) { "must be constant integer", Call); const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue(); - Assert(NumDeoptArgs == 0, - "gc.statepoint w/inline deopt operands is deprecated", Call); + Assert(NumDeoptArgs == 0, + "gc.statepoint w/inline deopt operands is deprecated", Call); - const int ExpectedNumArgs = 7 + NumCallArgs; - Assert(ExpectedNumArgs == (int)Call.arg_size(), - "gc.statepoint too many arguments", Call); + const int ExpectedNumArgs = 7 + NumCallArgs; + Assert(ExpectedNumArgs == (int)Call.arg_size(), + "gc.statepoint too many arguments", Call); // Check that the only uses of this gc.statepoint are gc.result or // gc.relocate calls which are tied to this statepoint and thus part @@ -2338,11 +2338,11 @@ void Verifier::visitFunction(const Function &F) { default: case CallingConv::C: break; - case CallingConv::X86_INTR: { - Assert(F.arg_empty() || Attrs.hasParamAttribute(0, Attribute::ByVal), - "Calling convention parameter requires byval", &F); - break; - } + case CallingConv::X86_INTR: { + Assert(F.arg_empty() || Attrs.hasParamAttribute(0, Attribute::ByVal), + "Calling convention parameter requires byval", &F); + break; + } case CallingConv::AMDGPU_KERNEL: case CallingConv::SPIR_KERNEL: Assert(F.getReturnType()->isVoidTy(), @@ -2355,28 +2355,28 @@ void Verifier::visitFunction(const Function &F) { case CallingConv::AMDGPU_CS: Assert(!F.hasStructRetAttr(), "Calling convention does not allow sret", &F); - if (F.getCallingConv() != CallingConv::SPIR_KERNEL) { - const unsigned StackAS = DL.getAllocaAddrSpace(); - unsigned i = 0; - for (const Argument &Arg : F.args()) { - Assert(!Attrs.hasParamAttribute(i, Attribute::ByVal), - "Calling convention disallows byval", &F); - Assert(!Attrs.hasParamAttribute(i, Attribute::Preallocated), - "Calling convention disallows preallocated", &F); - Assert(!Attrs.hasParamAttribute(i, Attribute::InAlloca), - "Calling convention disallows inalloca", &F); - - if (Attrs.hasParamAttribute(i, Attribute::ByRef)) { - // FIXME: Should also disallow LDS and GDS, but we don't have the enum - // value here. - Assert(Arg.getType()->getPointerAddressSpace() != StackAS, - "Calling convention disallows stack byref", &F); - } - - ++i; - } - } - + if (F.getCallingConv() != CallingConv::SPIR_KERNEL) { + const unsigned StackAS = DL.getAllocaAddrSpace(); + unsigned i = 0; + for (const Argument &Arg : F.args()) { + Assert(!Attrs.hasParamAttribute(i, Attribute::ByVal), + "Calling convention disallows byval", &F); + Assert(!Attrs.hasParamAttribute(i, Attribute::Preallocated), + "Calling convention disallows preallocated", &F); + Assert(!Attrs.hasParamAttribute(i, Attribute::InAlloca), + "Calling convention disallows inalloca", &F); + + if (Attrs.hasParamAttribute(i, Attribute::ByRef)) { + // FIXME: Should also disallow LDS and GDS, but we don't have the enum + // value here. + Assert(Arg.getType()->getPointerAddressSpace() != StackAS, + "Calling convention disallows stack byref", &F); + } + + ++i; + } + } + LLVM_FALLTHROUGH; case CallingConv::Fast: case CallingConv::Cold: @@ -2479,10 +2479,10 @@ void Verifier::visitFunction(const Function &F) { "function must have a single !dbg attachment", &F, I.second); AssertDI(isa<DISubprogram>(I.second), "function !dbg attachment must be a subprogram", &F, I.second); - AssertDI(cast<DISubprogram>(I.second)->isDistinct(), - "function definition may only have a distinct !dbg attachment", - &F); - + AssertDI(cast<DISubprogram>(I.second)->isDistinct(), + "function definition may only have a distinct !dbg attachment", + &F); + auto *SP = cast<DISubprogram>(I.second); const Function *&AttachedTo = DISubprogramAttachments[SP]; AssertDI(!AttachedTo || AttachedTo == &F, @@ -2577,7 +2577,7 @@ void Verifier::visitBasicBlock(BasicBlock &BB) { // Check constraints that this basic block imposes on all of the PHI nodes in // it. if (isa<PHINode>(BB.front())) { - SmallVector<BasicBlock *, 8> Preds(predecessors(&BB)); + SmallVector<BasicBlock *, 8> Preds(predecessors(&BB)); SmallVector<std::pair<BasicBlock*, Value*>, 8> Values; llvm::sort(Preds); for (const PHINode &PN : BB.phis()) { @@ -2971,8 +2971,8 @@ void Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) { Assert(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(), "AddrSpaceCast must be between different address spaces", &I); if (auto *SrcVTy = dyn_cast<VectorType>(SrcTy)) - Assert(SrcVTy->getElementCount() == - cast<VectorType>(DestTy)->getElementCount(), + Assert(SrcVTy->getElementCount() == + cast<VectorType>(DestTy)->getElementCount(), "AddrSpaceCast vector pointer number of elements mismatch", &I); visitInstruction(I); } @@ -3258,19 +3258,19 @@ static bool isTypeCongruent(Type *L, Type *R) { static AttrBuilder getParameterABIAttributes(int I, AttributeList Attrs) { static const Attribute::AttrKind ABIAttrs[] = { - Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca, - Attribute::InReg, Attribute::SwiftSelf, Attribute::SwiftError, - Attribute::Preallocated, Attribute::ByRef}; + Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca, + Attribute::InReg, Attribute::SwiftSelf, Attribute::SwiftError, + Attribute::Preallocated, Attribute::ByRef}; AttrBuilder Copy; for (auto AK : ABIAttrs) { if (Attrs.hasParamAttribute(I, AK)) Copy.addAttribute(AK); } - - // `align` is ABI-affecting only in combination with `byval` or `byref`. + + // `align` is ABI-affecting only in combination with `byval` or `byref`. if (Attrs.hasParamAttribute(I, Attribute::Alignment) && - (Attrs.hasParamAttribute(I, Attribute::ByVal) || - Attrs.hasParamAttribute(I, Attribute::ByRef))) + (Attrs.hasParamAttribute(I, Attribute::ByVal) || + Attrs.hasParamAttribute(I, Attribute::ByRef))) Copy.addAlignmentAttr(Attrs.getParamAlignment(I)); return Copy; } @@ -3506,7 +3506,7 @@ void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) { "GEP base pointer is not a vector or a vector of pointers", &GEP); Assert(GEP.getSourceElementType()->isSized(), "GEP into unsized type!", &GEP); - SmallVector<Value *, 16> Idxs(GEP.indices()); + SmallVector<Value *, 16> Idxs(GEP.indices()); Assert(all_of( Idxs, [](Value* V) { return V->getType()->isIntOrIntVectorTy(); }), "GEP indexes must be integers", &GEP); @@ -4291,14 +4291,14 @@ void Verifier::visitProfMetadata(Instruction &I, MDNode *MD) { } } -void Verifier::visitAnnotationMetadata(MDNode *Annotation) { - Assert(isa<MDTuple>(Annotation), "annotation must be a tuple"); - Assert(Annotation->getNumOperands() >= 1, - "annotation must have at least one operand"); - for (const MDOperand &Op : Annotation->operands()) - Assert(isa<MDString>(Op.get()), "operands must be strings"); -} - +void Verifier::visitAnnotationMetadata(MDNode *Annotation) { + Assert(isa<MDTuple>(Annotation), "annotation must be a tuple"); + Assert(Annotation->getNumOperands() >= 1, + "annotation must have at least one operand"); + for (const MDOperand &Op : Annotation->operands()) + Assert(isa<MDString>(Op.get()), "operands must be strings"); +} + /// verifyInstruction - Verify that an instruction is well formed. /// void Verifier::visitInstruction(Instruction &I) { @@ -4368,7 +4368,7 @@ void Verifier::visitInstruction(Instruction &I) { F->getIntrinsicID() == Intrinsic::experimental_patchpoint_void || F->getIntrinsicID() == Intrinsic::experimental_patchpoint_i64 || F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint || - F->getIntrinsicID() == Intrinsic::wasm_rethrow, + F->getIntrinsicID() == Intrinsic::wasm_rethrow, "Cannot invoke an intrinsic other than donothing, patchpoint, " "statepoint, coro_resume or coro_destroy", &I); @@ -4459,9 +4459,9 @@ void Verifier::visitInstruction(Instruction &I) { if (MDNode *MD = I.getMetadata(LLVMContext::MD_prof)) visitProfMetadata(I, MD); - if (MDNode *Annotation = I.getMetadata(LLVMContext::MD_annotation)) - visitAnnotationMetadata(Annotation); - + if (MDNode *Annotation = I.getMetadata(LLVMContext::MD_annotation)) + visitAnnotationMetadata(Annotation); + if (MDNode *N = I.getDebugLoc().getAsMDNode()) { AssertDI(isa<DILocation>(N), "invalid !dbg metadata attachment", &I, N); visitMDNode(*N, AreDebugLocsAllowed::Yes); @@ -4548,30 +4548,30 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) { "tags must be valid attribute names"); Attribute::AttrKind Kind = Attribute::getAttrKindFromName(Elem.Tag->getKey()); - unsigned ArgCount = Elem.End - Elem.Begin; - if (Kind == Attribute::Alignment) { - Assert(ArgCount <= 3 && ArgCount >= 2, - "alignment assumptions should have 2 or 3 arguments"); - Assert(Call.getOperand(Elem.Begin)->getType()->isPointerTy(), - "first argument should be a pointer"); - Assert(Call.getOperand(Elem.Begin + 1)->getType()->isIntegerTy(), - "second argument should be an integer"); - if (ArgCount == 3) - Assert(Call.getOperand(Elem.Begin + 2)->getType()->isIntegerTy(), - "third argument should be an integer if present"); - return; - } - Assert(ArgCount <= 2, "to many arguments"); + unsigned ArgCount = Elem.End - Elem.Begin; + if (Kind == Attribute::Alignment) { + Assert(ArgCount <= 3 && ArgCount >= 2, + "alignment assumptions should have 2 or 3 arguments"); + Assert(Call.getOperand(Elem.Begin)->getType()->isPointerTy(), + "first argument should be a pointer"); + Assert(Call.getOperand(Elem.Begin + 1)->getType()->isIntegerTy(), + "second argument should be an integer"); + if (ArgCount == 3) + Assert(Call.getOperand(Elem.Begin + 2)->getType()->isIntegerTy(), + "third argument should be an integer if present"); + return; + } + Assert(ArgCount <= 2, "to many arguments"); if (Kind == Attribute::None) break; if (Attribute::doesAttrKindHaveArgument(Kind)) { - Assert(ArgCount == 2, "this attribute should have 2 arguments"); + Assert(ArgCount == 2, "this attribute should have 2 arguments"); Assert(isa<ConstantInt>(Call.getOperand(Elem.Begin + 1)), "the second argument should be a constant integral value"); } else if (isFuncOnlyAttr(Kind)) { - Assert((ArgCount) == 0, "this attribute has no argument"); + Assert((ArgCount) == 0, "this attribute has no argument"); } else if (!isFuncOrArgAttr(Kind)) { - Assert((ArgCount) == 1, "this attribute should have one argument"); + Assert((ArgCount) == 1, "this attribute should have one argument"); } } break; @@ -5010,17 +5010,17 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) { case Intrinsic::sadd_sat: case Intrinsic::uadd_sat: case Intrinsic::ssub_sat: - case Intrinsic::usub_sat: - case Intrinsic::sshl_sat: - case Intrinsic::ushl_sat: { + case Intrinsic::usub_sat: + case Intrinsic::sshl_sat: + case Intrinsic::ushl_sat: { Value *Op1 = Call.getArgOperand(0); Value *Op2 = Call.getArgOperand(1); Assert(Op1->getType()->isIntOrIntVectorTy(), - "first operand of [us][add|sub|shl]_sat must be an int type or " - "vector of ints"); + "first operand of [us][add|sub|shl]_sat must be an int type or " + "vector of ints"); Assert(Op2->getType()->isIntOrIntVectorTy(), - "second operand of [us][add|sub|shl]_sat must be an int type or " - "vector of ints"); + "second operand of [us][add|sub|shl]_sat must be an int type or " + "vector of ints"); break; } case Intrinsic::smul_fix: @@ -5073,14 +5073,14 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) { Assert(Size % 16 == 0, "bswap must be an even number of bytes", &Call); break; } - case Intrinsic::invariant_start: { - ConstantInt *InvariantSize = dyn_cast<ConstantInt>(Call.getArgOperand(0)); - Assert(InvariantSize && - (!InvariantSize->isNegative() || InvariantSize->isMinusOne()), - "invariant_start parameter must be -1, 0 or a positive number", - &Call); - break; - } + case Intrinsic::invariant_start: { + ConstantInt *InvariantSize = dyn_cast<ConstantInt>(Call.getArgOperand(0)); + Assert(InvariantSize && + (!InvariantSize->isNegative() || InvariantSize->isMinusOne()), + "invariant_start parameter must be -1, 0 or a positive number", + &Call); + break; + } case Intrinsic::matrix_multiply: case Intrinsic::matrix_transpose: case Intrinsic::matrix_column_major_load: @@ -5144,7 +5144,7 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) { "Vector element type mismatch of the result and second operand " "vector!", IF); - Assert(cast<FixedVectorType>(ResultTy)->getNumElements() == + Assert(cast<FixedVectorType>(ResultTy)->getNumElements() == NumRows->getZExtValue() * NumColumns->getZExtValue(), "Result of a matrix operation does not fit in the returned vector!"); @@ -5154,30 +5154,30 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) { break; } - case Intrinsic::experimental_vector_insert: { - VectorType *VecTy = cast<VectorType>(Call.getArgOperand(0)->getType()); - VectorType *SubVecTy = cast<VectorType>(Call.getArgOperand(1)->getType()); - - Assert(VecTy->getElementType() == SubVecTy->getElementType(), - "experimental_vector_insert parameters must have the same element " - "type.", - &Call); - break; - } - case Intrinsic::experimental_vector_extract: { - VectorType *ResultTy = cast<VectorType>(Call.getType()); - VectorType *VecTy = cast<VectorType>(Call.getArgOperand(0)->getType()); - - Assert(ResultTy->getElementType() == VecTy->getElementType(), - "experimental_vector_extract result must have the same element " - "type as the input vector.", - &Call); - break; - } - case Intrinsic::experimental_noalias_scope_decl: { - NoAliasScopeDecls.push_back(cast<IntrinsicInst>(&Call)); - break; - } + case Intrinsic::experimental_vector_insert: { + VectorType *VecTy = cast<VectorType>(Call.getArgOperand(0)->getType()); + VectorType *SubVecTy = cast<VectorType>(Call.getArgOperand(1)->getType()); + + Assert(VecTy->getElementType() == SubVecTy->getElementType(), + "experimental_vector_insert parameters must have the same element " + "type.", + &Call); + break; + } + case Intrinsic::experimental_vector_extract: { + VectorType *ResultTy = cast<VectorType>(Call.getType()); + VectorType *VecTy = cast<VectorType>(Call.getArgOperand(0)->getType()); + + Assert(ResultTy->getElementType() == VecTy->getElementType(), + "experimental_vector_extract result must have the same element " + "type as the input vector.", + &Call); + break; + } + case Intrinsic::experimental_noalias_scope_decl: { + NoAliasScopeDecls.push_back(cast<IntrinsicInst>(&Call)); + break; + } }; } @@ -5254,7 +5254,7 @@ void Verifier::visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI) { Assert(Operand->getType()->isFPOrFPVectorTy(), "Intrinsic first argument must be floating point", &FPI); if (auto *OperandT = dyn_cast<VectorType>(Operand->getType())) { - NumSrcElem = cast<FixedVectorType>(OperandT)->getNumElements(); + NumSrcElem = cast<FixedVectorType>(OperandT)->getNumElements(); } Operand = &FPI; @@ -5263,7 +5263,7 @@ void Verifier::visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI) { Assert(Operand->getType()->isIntOrIntVectorTy(), "Intrinsic result must be an integer", &FPI); if (auto *OperandT = dyn_cast<VectorType>(Operand->getType())) { - Assert(NumSrcElem == cast<FixedVectorType>(OperandT)->getNumElements(), + Assert(NumSrcElem == cast<FixedVectorType>(OperandT)->getNumElements(), "Intrinsic first argument and result vector lengths must be equal", &FPI); } @@ -5277,7 +5277,7 @@ void Verifier::visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI) { Assert(Operand->getType()->isIntOrIntVectorTy(), "Intrinsic first argument must be integer", &FPI); if (auto *OperandT = dyn_cast<VectorType>(Operand->getType())) { - NumSrcElem = cast<FixedVectorType>(OperandT)->getNumElements(); + NumSrcElem = cast<FixedVectorType>(OperandT)->getNumElements(); } Operand = &FPI; @@ -5286,7 +5286,7 @@ void Verifier::visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI) { Assert(Operand->getType()->isFPOrFPVectorTy(), "Intrinsic result must be a floating point", &FPI); if (auto *OperandT = dyn_cast<VectorType>(Operand->getType())) { - Assert(NumSrcElem == cast<FixedVectorType>(OperandT)->getNumElements(), + Assert(NumSrcElem == cast<FixedVectorType>(OperandT)->getNumElements(), "Intrinsic first argument and result vector lengths must be equal", &FPI); } @@ -5305,8 +5305,8 @@ void Verifier::visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI) { Assert(OperandTy->isVectorTy() == ResultTy->isVectorTy(), "Intrinsic first argument and result disagree on vector use", &FPI); if (OperandTy->isVectorTy()) { - Assert(cast<FixedVectorType>(OperandTy)->getNumElements() == - cast<FixedVectorType>(ResultTy)->getNumElements(), + Assert(cast<FixedVectorType>(OperandTy)->getNumElements() == + cast<FixedVectorType>(ResultTy)->getNumElements(), "Intrinsic first argument and result vector lengths must be equal", &FPI); } @@ -5528,75 +5528,75 @@ void Verifier::verifySourceDebugInfo(const DICompileUnit &U, const DIFile &F) { "inconsistent use of embedded source"); } -void Verifier::verifyNoAliasScopeDecl() { - if (NoAliasScopeDecls.empty()) - return; - - // only a single scope must be declared at a time. - for (auto *II : NoAliasScopeDecls) { - assert(II->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl && - "Not a llvm.experimental.noalias.scope.decl ?"); - const auto *ScopeListMV = dyn_cast<MetadataAsValue>( - II->getOperand(Intrinsic::NoAliasScopeDeclScopeArg)); - Assert(ScopeListMV != nullptr, - "llvm.experimental.noalias.scope.decl must have a MetadataAsValue " - "argument", - II); - - const auto *ScopeListMD = dyn_cast<MDNode>(ScopeListMV->getMetadata()); - Assert(ScopeListMD != nullptr, "!id.scope.list must point to an MDNode", - II); - Assert(ScopeListMD->getNumOperands() == 1, - "!id.scope.list must point to a list with a single scope", II); - } - - // Only check the domination rule when requested. Once all passes have been - // adapted this option can go away. - if (!VerifyNoAliasScopeDomination) - return; - - // Now sort the intrinsics based on the scope MDNode so that declarations of - // the same scopes are next to each other. - auto GetScope = [](IntrinsicInst *II) { - const auto *ScopeListMV = cast<MetadataAsValue>( - II->getOperand(Intrinsic::NoAliasScopeDeclScopeArg)); - return &cast<MDNode>(ScopeListMV->getMetadata())->getOperand(0); - }; - - // We are sorting on MDNode pointers here. For valid input IR this is ok. - // TODO: Sort on Metadata ID to avoid non-deterministic error messages. - auto Compare = [GetScope](IntrinsicInst *Lhs, IntrinsicInst *Rhs) { - return GetScope(Lhs) < GetScope(Rhs); - }; - - llvm::sort(NoAliasScopeDecls, Compare); - - // Go over the intrinsics and check that for the same scope, they are not - // dominating each other. - auto ItCurrent = NoAliasScopeDecls.begin(); - while (ItCurrent != NoAliasScopeDecls.end()) { - auto CurScope = GetScope(*ItCurrent); - auto ItNext = ItCurrent; - do { - ++ItNext; - } while (ItNext != NoAliasScopeDecls.end() && - GetScope(*ItNext) == CurScope); - - // [ItCurrent, ItNext) represents the declarations for the same scope. - // Ensure they are not dominating each other.. but only if it is not too - // expensive. - if (ItNext - ItCurrent < 32) - for (auto *I : llvm::make_range(ItCurrent, ItNext)) - for (auto *J : llvm::make_range(ItCurrent, ItNext)) - if (I != J) - Assert(!DT.dominates(I, J), - "llvm.experimental.noalias.scope.decl dominates another one " - "with the same scope", - I); - ItCurrent = ItNext; - } -} - +void Verifier::verifyNoAliasScopeDecl() { + if (NoAliasScopeDecls.empty()) + return; + + // only a single scope must be declared at a time. + for (auto *II : NoAliasScopeDecls) { + assert(II->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl && + "Not a llvm.experimental.noalias.scope.decl ?"); + const auto *ScopeListMV = dyn_cast<MetadataAsValue>( + II->getOperand(Intrinsic::NoAliasScopeDeclScopeArg)); + Assert(ScopeListMV != nullptr, + "llvm.experimental.noalias.scope.decl must have a MetadataAsValue " + "argument", + II); + + const auto *ScopeListMD = dyn_cast<MDNode>(ScopeListMV->getMetadata()); + Assert(ScopeListMD != nullptr, "!id.scope.list must point to an MDNode", + II); + Assert(ScopeListMD->getNumOperands() == 1, + "!id.scope.list must point to a list with a single scope", II); + } + + // Only check the domination rule when requested. Once all passes have been + // adapted this option can go away. + if (!VerifyNoAliasScopeDomination) + return; + + // Now sort the intrinsics based on the scope MDNode so that declarations of + // the same scopes are next to each other. + auto GetScope = [](IntrinsicInst *II) { + const auto *ScopeListMV = cast<MetadataAsValue>( + II->getOperand(Intrinsic::NoAliasScopeDeclScopeArg)); + return &cast<MDNode>(ScopeListMV->getMetadata())->getOperand(0); + }; + + // We are sorting on MDNode pointers here. For valid input IR this is ok. + // TODO: Sort on Metadata ID to avoid non-deterministic error messages. + auto Compare = [GetScope](IntrinsicInst *Lhs, IntrinsicInst *Rhs) { + return GetScope(Lhs) < GetScope(Rhs); + }; + + llvm::sort(NoAliasScopeDecls, Compare); + + // Go over the intrinsics and check that for the same scope, they are not + // dominating each other. + auto ItCurrent = NoAliasScopeDecls.begin(); + while (ItCurrent != NoAliasScopeDecls.end()) { + auto CurScope = GetScope(*ItCurrent); + auto ItNext = ItCurrent; + do { + ++ItNext; + } while (ItNext != NoAliasScopeDecls.end() && + GetScope(*ItNext) == CurScope); + + // [ItCurrent, ItNext) represents the declarations for the same scope. + // Ensure they are not dominating each other.. but only if it is not too + // expensive. + if (ItNext - ItCurrent < 32) + for (auto *I : llvm::make_range(ItCurrent, ItNext)) + for (auto *J : llvm::make_range(ItCurrent, ItNext)) + if (I != J) + Assert(!DT.dominates(I, J), + "llvm.experimental.noalias.scope.decl dominates another one " + "with the same scope", + I); + ItCurrent = ItNext; + } +} + //===----------------------------------------------------------------------===// // Implement the public interfaces to this file... //===----------------------------------------------------------------------===// diff --git a/contrib/libs/llvm12/lib/IR/ya.make b/contrib/libs/llvm12/lib/IR/ya.make index 5c27c5b009..0f5f8b0084 100644 --- a/contrib/libs/llvm12/lib/IR/ya.make +++ b/contrib/libs/llvm12/lib/IR/ya.make @@ -12,11 +12,11 @@ LICENSE(Apache-2.0 WITH LLVM-exception) LICENSE_TEXTS(.yandex_meta/licenses.list.txt) PEERDIR( - contrib/libs/llvm12 - contrib/libs/llvm12/include - contrib/libs/llvm12/lib/BinaryFormat - contrib/libs/llvm12/lib/Remarks - contrib/libs/llvm12/lib/Support + contrib/libs/llvm12 + contrib/libs/llvm12/include + contrib/libs/llvm12/lib/BinaryFormat + contrib/libs/llvm12/lib/Remarks + contrib/libs/llvm12/lib/Support ) ADDINCL( @@ -30,7 +30,7 @@ NO_UTIL() SRCS( AbstractCallSite.cpp AsmWriter.cpp - Assumptions.cpp + Assumptions.cpp Attributes.cpp AutoUpgrade.cpp BasicBlock.cpp @@ -74,13 +74,13 @@ SRCS( PassManager.cpp PassRegistry.cpp PassTimingInfo.cpp - PrintPasses.cpp + PrintPasses.cpp ProfileSummary.cpp - PseudoProbe.cpp - ReplaceConstant.cpp + PseudoProbe.cpp + ReplaceConstant.cpp SafepointIRVerifier.cpp Statepoint.cpp - StructuralHash.cpp + StructuralHash.cpp Type.cpp TypeFinder.cpp Use.cpp |