diff options
Diffstat (limited to 'llvm/include')
45 files changed, 404 insertions, 216 deletions
diff --git a/llvm/include/llvm-c/Core.h b/llvm/include/llvm-c/Core.h index 3d22f859..4e380d9 100644 --- a/llvm/include/llvm-c/Core.h +++ b/llvm/include/llvm-c/Core.h @@ -4757,7 +4757,7 @@ LLVM_C_ABI LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, LLVM_C_ABI LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, const char *Name); -LLVM_C_ABI LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst); +LLVM_C_ABI LLVMBool LLVMGetVolatile(LLVMValueRef Inst); LLVM_C_ABI void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile); LLVM_C_ABI LLVMBool LLVMGetWeak(LLVMValueRef CmpXchgInst); diff --git a/llvm/include/llvm/ADT/APFloat.h b/llvm/include/llvm/ADT/APFloat.h index 6bc6284..a1bfce7 100644 --- a/llvm/include/llvm/ADT/APFloat.h +++ b/llvm/include/llvm/ADT/APFloat.h @@ -1313,7 +1313,7 @@ public: /// Assuming this is an IEEE-754 NaN value, quiet its signaling bit. /// This preserves the sign and payload bits. - APFloat makeQuiet() const { + [[nodiscard]] APFloat makeQuiet() const { APFloat Result(*this); Result.getIEEE().makeQuiet(); return Result; diff --git a/llvm/include/llvm/ADT/Bitfields.h b/llvm/include/llvm/ADT/Bitfields.h index 4064d71..1af2761 100644 --- a/llvm/include/llvm/ADT/Bitfields.h +++ b/llvm/include/llvm/ADT/Bitfields.h @@ -86,89 +86,43 @@ #include <limits> // numeric_limits #include <type_traits> +#include "llvm/Support/MathExtras.h" + namespace llvm { namespace bitfields_details { -/// A struct defining useful bit patterns for n-bits integer types. -template <typename T, unsigned Bits> struct BitPatterns { - /// Bit patterns are forged using the equivalent `Unsigned` type because of - /// undefined operations over signed types (e.g. Bitwise shift operators). - /// Moreover same size casting from unsigned to signed is well defined but not - /// the other way around. - using Unsigned = std::make_unsigned_t<T>; - static_assert(sizeof(Unsigned) == sizeof(T), "Types must have same size"); - - static constexpr unsigned TypeBits = sizeof(Unsigned) * CHAR_BIT; - static_assert(TypeBits >= Bits, "n-bit must fit in T"); - - /// e.g. with TypeBits == 8 and Bits == 6. - static constexpr Unsigned AllZeros = Unsigned(0); // 00000000 - static constexpr Unsigned AllOnes = ~Unsigned(0); // 11111111 - static constexpr Unsigned Umin = AllZeros; // 00000000 - static constexpr Unsigned Umax = AllOnes >> (TypeBits - Bits); // 00111111 - static constexpr Unsigned SignBitMask = Unsigned(1) << (Bits - 1); // 00100000 - static constexpr Unsigned Smax = Umax >> 1U; // 00011111 - static constexpr Unsigned Smin = ~Smax; // 11100000 - static constexpr Unsigned SignExtend = Unsigned(Smin << 1U); // 11000000 -}; - -/// `Compressor` is used to manipulate the bits of a (possibly signed) integer -/// type so it can be packed and unpacked into a `bits` sized integer, -/// `Compressor` is specialized on signed-ness so no runtime cost is incurred. -/// The `pack` method also checks that the passed in `UserValue` is valid. -template <typename T, unsigned Bits, bool = std::is_unsigned<T>::value> -struct Compressor { - static_assert(std::is_unsigned<T>::value, "T must be unsigned"); - using BP = BitPatterns<T, Bits>; - - static T pack(T UserValue, T UserMaxValue) { - assert(UserValue <= UserMaxValue && "value is too big"); - assert(UserValue <= BP::Umax && "value is too big"); - return UserValue; - } - - static T unpack(T StorageValue) { return StorageValue; } -}; - -template <typename T, unsigned Bits> struct Compressor<T, Bits, false> { - static_assert(std::is_signed<T>::value, "T must be signed"); - using BP = BitPatterns<T, Bits>; - - static T pack(T UserValue, T UserMaxValue) { - assert(UserValue <= UserMaxValue && "value is too big"); - assert(UserValue <= T(BP::Smax) && "value is too big"); - assert(UserValue >= T(BP::Smin) && "value is too small"); - if (UserValue < 0) - UserValue &= ~BP::SignExtend; - return UserValue; - } - - static T unpack(T StorageValue) { - if (StorageValue >= T(BP::SignBitMask)) - StorageValue |= BP::SignExtend; - return StorageValue; - } -}; - /// Impl is where Bifield description and Storage are put together to interact /// with values. template <typename Bitfield, typename StorageType> struct Impl { static_assert(std::is_unsigned<StorageType>::value, "Storage must be unsigned"); using IntegerType = typename Bitfield::IntegerType; - using C = Compressor<IntegerType, Bitfield::Bits>; - using BP = BitPatterns<StorageType, Bitfield::Bits>; static constexpr size_t StorageBits = sizeof(StorageType) * CHAR_BIT; static_assert(Bitfield::FirstBit <= StorageBits, "Data must fit in mask"); static_assert(Bitfield::LastBit <= StorageBits, "Data must fit in mask"); - static constexpr StorageType Mask = BP::Umax << Bitfield::Shift; + static constexpr StorageType LowMask = + maskTrailingOnes<StorageType>(Bitfield::Bits); + static constexpr StorageType Mask = LowMask << Bitfield::Shift; + + /// Validates that `UserValue` fits within the bitfield's range. + static void checkValue(IntegerType UserValue, IntegerType UserMaxValue) { + assert(UserValue <= UserMaxValue && "value is too big"); + if constexpr (std::is_unsigned_v<IntegerType>) { + assert(isUInt<Bitfield::Bits>(UserValue) && "value is too big"); + } else { + static_assert(std::is_signed_v<IntegerType>, + "IntegerType must be signed"); + assert(isInt<Bitfield::Bits>(UserValue) && "value is out of range"); + } + } /// Checks `UserValue` is within bounds and packs it between `FirstBit` and /// `LastBit` of `Packed` leaving the rest unchanged. static void update(StorageType &Packed, IntegerType UserValue) { - const StorageType StorageValue = C::pack(UserValue, Bitfield::UserMaxValue); + checkValue(UserValue, Bitfield::UserMaxValue); + const StorageType StorageValue = UserValue & LowMask; Packed &= ~Mask; Packed |= StorageValue << Bitfield::Shift; } @@ -177,7 +131,9 @@ template <typename Bitfield, typename StorageType> struct Impl { /// an`IntegerType`. static IntegerType extract(StorageType Packed) { const StorageType StorageValue = (Packed & Mask) >> Bitfield::Shift; - return C::unpack(StorageValue); + if constexpr (std::is_signed_v<IntegerType>) + return SignExtend64<Bitfield::Bits>(StorageValue); + return StorageValue; } /// Interprets bits between `FirstBit` and `LastBit` of `Packed` as diff --git a/llvm/include/llvm/ADT/StringExtras.h b/llvm/include/llvm/ADT/StringExtras.h index 7d81c63..2440e76 100644 --- a/llvm/include/llvm/ADT/StringExtras.h +++ b/llvm/include/llvm/ADT/StringExtras.h @@ -529,13 +529,15 @@ inline std::string join_items(Sep Separator, Args &&... Items) { class ListSeparator { bool First = true; StringRef Separator; + StringRef Prefix; public: - ListSeparator(StringRef Separator = ", ") : Separator(Separator) {} + ListSeparator(StringRef Separator = ", ", StringRef Prefix = "") + : Separator(Separator), Prefix(Prefix) {} operator StringRef() { if (First) { First = false; - return {}; + return Prefix; } return Separator; } diff --git a/llvm/include/llvm/ADT/StringSwitch.h b/llvm/include/llvm/ADT/StringSwitch.h index 0ce7c57a..a96535c 100644 --- a/llvm/include/llvm/ADT/StringSwitch.h +++ b/llvm/include/llvm/ADT/StringSwitch.h @@ -17,6 +17,7 @@ #include "llvm/Support/ErrorHandling.h" #include <cassert> #include <cstring> +#include <initializer_list> #include <optional> namespace llvm { @@ -85,55 +86,60 @@ public: return *this; } + StringSwitch &Cases(std::initializer_list<StringLiteral> CaseStrings, + T Value) { + return CasesImpl(Value, CaseStrings); + } + StringSwitch &Cases(StringLiteral S0, StringLiteral S1, T Value) { - return CasesImpl(Value, S0, S1); + return CasesImpl(Value, {S0, S1}); } StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, T Value) { - return CasesImpl(Value, S0, S1, S2); + return CasesImpl(Value, {S0, S1, S2}); } StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, T Value) { - return CasesImpl(Value, S0, S1, S2, S3); + return CasesImpl(Value, {S0, S1, S2, S3}); } StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, T Value) { - return CasesImpl(Value, S0, S1, S2, S3, S4); + return CasesImpl(Value, {S0, S1, S2, S3, S4}); } StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, StringLiteral S5, T Value) { - return CasesImpl(Value, S0, S1, S2, S3, S4, S5); + return CasesImpl(Value, {S0, S1, S2, S3, S4, S5}); } StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, StringLiteral S5, StringLiteral S6, T Value) { - return CasesImpl(Value, S0, S1, S2, S3, S4, S5, S6); + return CasesImpl(Value, {S0, S1, S2, S3, S4, S5, S6}); } StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, StringLiteral S5, StringLiteral S6, StringLiteral S7, T Value) { - return CasesImpl(Value, S0, S1, S2, S3, S4, S5, S6, S7); + return CasesImpl(Value, {S0, S1, S2, S3, S4, S5, S6, S7}); } StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, StringLiteral S5, StringLiteral S6, StringLiteral S7, StringLiteral S8, T Value) { - return CasesImpl(Value, S0, S1, S2, S3, S4, S5, S6, S7, S8); + return CasesImpl(Value, {S0, S1, S2, S3, S4, S5, S6, S7, S8}); } StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, StringLiteral S5, StringLiteral S6, StringLiteral S7, StringLiteral S8, StringLiteral S9, T Value) { - return CasesImpl(Value, S0, S1, S2, S3, S4, S5, S6, S7, S8, S9); + return CasesImpl(Value, {S0, S1, S2, S3, S4, S5, S6, S7, S8, S9}); } // Case-insensitive case matchers. @@ -156,23 +162,28 @@ public: return *this; } + StringSwitch &CasesLower(std::initializer_list<StringLiteral> CaseStrings, + T Value) { + return CasesLowerImpl(Value, CaseStrings); + } + StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, T Value) { - return CasesLowerImpl(Value, S0, S1); + return CasesLowerImpl(Value, {S0, S1}); } StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, StringLiteral S2, T Value) { - return CasesLowerImpl(Value, S0, S1, S2); + return CasesLowerImpl(Value, {S0, S1, S2}); } StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, T Value) { - return CasesLowerImpl(Value, S0, S1, S2, S3); + return CasesLowerImpl(Value, {S0, S1, S2, S3}); } StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, T Value) { - return CasesLowerImpl(Value, S0, S1, S2, S3, S4); + return CasesLowerImpl(Value, {S0, S1, S2, S3, S4}); } [[nodiscard]] R Default(T Value) { @@ -211,16 +222,21 @@ private: return false; } - template <typename... Args> StringSwitch &CasesImpl(T &Value, Args... Cases) { + StringSwitch &CasesImpl(T &Value, + std::initializer_list<StringLiteral> Cases) { // Stop matching after the string is found. - (... || CaseImpl(Value, Cases)); + for (StringLiteral S : Cases) + if (CaseImpl(Value, S)) + break; return *this; } - template <typename... Args> - StringSwitch &CasesLowerImpl(T &Value, Args... Cases) { + StringSwitch &CasesLowerImpl(T &Value, + std::initializer_list<StringLiteral> Cases) { // Stop matching after the string is found. - (... || CaseLowerImpl(Value, Cases)); + for (StringLiteral S : Cases) + if (CaseLowerImpl(Value, S)) + break; return *this; } }; diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h index 8876e4e..e5a6c8c 100644 --- a/llvm/include/llvm/Analysis/ScalarEvolution.h +++ b/llvm/include/llvm/Analysis/ScalarEvolution.h @@ -2316,10 +2316,6 @@ private: /// an add rec on said loop. void getUsedLoops(const SCEV *S, SmallPtrSetImpl<const Loop *> &LoopsUsed); - /// Try to match the pattern generated by getURemExpr(A, B). If successful, - /// Assign A and B to LHS and RHS, respectively. - LLVM_ABI bool matchURem(const SCEV *Expr, const SCEV *&LHS, const SCEV *&RHS); - /// Look for a SCEV expression with type `SCEVType` and operands `Ops` in /// `UniqueSCEVs`. Return if found, else nullptr. SCEV *findExistingSCEVInCache(SCEVTypes SCEVType, ArrayRef<const SCEV *> Ops); diff --git a/llvm/include/llvm/Analysis/ScalarEvolutionPatternMatch.h b/llvm/include/llvm/Analysis/ScalarEvolutionPatternMatch.h index 164b46b..871028d 100644 --- a/llvm/include/llvm/Analysis/ScalarEvolutionPatternMatch.h +++ b/llvm/include/llvm/Analysis/ScalarEvolutionPatternMatch.h @@ -182,6 +182,12 @@ m_scev_PtrToInt(const Op0_t &Op0) { return SCEVUnaryExpr_match<SCEVPtrToIntExpr, Op0_t>(Op0); } +template <typename Op0_t> +inline SCEVUnaryExpr_match<SCEVTruncateExpr, Op0_t> +m_scev_Trunc(const Op0_t &Op0) { + return m_scev_Unary<SCEVTruncateExpr>(Op0); +} + /// Match a binary SCEV. template <typename SCEVTy, typename Op0_t, typename Op1_t, SCEV::NoWrapFlags WrapFlags = SCEV::FlagAnyWrap, @@ -246,6 +252,80 @@ m_scev_UDiv(const Op0_t &Op0, const Op1_t &Op1) { return m_scev_Binary<SCEVUDivExpr>(Op0, Op1); } +/// Match unsigned remainder pattern. +/// Matches patterns generated by getURemExpr. +template <typename Op0_t, typename Op1_t> struct SCEVURem_match { + Op0_t Op0; + Op1_t Op1; + ScalarEvolution &SE; + + SCEVURem_match(Op0_t Op0, Op1_t Op1, ScalarEvolution &SE) + : Op0(Op0), Op1(Op1), SE(SE) {} + + bool match(const SCEV *Expr) const { + if (Expr->getType()->isPointerTy()) + return false; + + // Try to match 'zext (trunc A to iB) to iY', which is used + // for URem with constant power-of-2 second operands. Make sure the size of + // the operand A matches the size of the whole expressions. + const SCEV *LHS; + if (SCEVPatternMatch::match(Expr, m_scev_ZExt(m_scev_Trunc(m_SCEV(LHS))))) { + Type *TruncTy = cast<SCEVZeroExtendExpr>(Expr)->getOperand()->getType(); + // Bail out if the type of the LHS is larger than the type of the + // expression for now. + if (SE.getTypeSizeInBits(LHS->getType()) > + SE.getTypeSizeInBits(Expr->getType())) + return false; + if (LHS->getType() != Expr->getType()) + LHS = SE.getZeroExtendExpr(LHS, Expr->getType()); + const SCEV *RHS = + SE.getConstant(APInt(SE.getTypeSizeInBits(Expr->getType()), 1) + << SE.getTypeSizeInBits(TruncTy)); + return Op0.match(LHS) && Op1.match(RHS); + } + const auto *Add = dyn_cast<SCEVAddExpr>(Expr); + if (Add == nullptr || Add->getNumOperands() != 2) + return false; + + const SCEV *A = Add->getOperand(1); + const auto *Mul = dyn_cast<SCEVMulExpr>(Add->getOperand(0)); + + if (Mul == nullptr) + return false; + + const auto MatchURemWithDivisor = [&](const SCEV *B) { + // (SomeExpr + (-(SomeExpr / B) * B)). + if (Expr == SE.getURemExpr(A, B)) + return Op0.match(A) && Op1.match(B); + return false; + }; + + // (SomeExpr + (-1 * (SomeExpr / B) * B)). + if (Mul->getNumOperands() == 3 && isa<SCEVConstant>(Mul->getOperand(0))) + return MatchURemWithDivisor(Mul->getOperand(1)) || + MatchURemWithDivisor(Mul->getOperand(2)); + + // (SomeExpr + ((-SomeExpr / B) * B)) or (SomeExpr + ((SomeExpr / B) * -B)). + if (Mul->getNumOperands() == 2) + return MatchURemWithDivisor(Mul->getOperand(1)) || + MatchURemWithDivisor(Mul->getOperand(0)) || + MatchURemWithDivisor(SE.getNegativeSCEV(Mul->getOperand(1))) || + MatchURemWithDivisor(SE.getNegativeSCEV(Mul->getOperand(0))); + return false; + } +}; + +/// Match the mathematical pattern A - (A / B) * B, where A and B can be +/// arbitrary expressions. Also match zext (trunc A to iB) to iY, which is used +/// for URem with constant power-of-2 second operands. It's not always easy, as +/// A and B can be folded (imagine A is X / 2, and B is 4, A / B becomes X / 8). +template <typename Op0_t, typename Op1_t> +inline SCEVURem_match<Op0_t, Op1_t> m_scev_URem(Op0_t LHS, Op1_t RHS, + ScalarEvolution &SE) { + return SCEVURem_match<Op0_t, Op1_t>(LHS, RHS, SE); +} + inline class_match<const Loop> m_Loop() { return class_match<const Loop>(); } /// Match an affine SCEVAddRecExpr. diff --git a/llvm/include/llvm/Analysis/StaticDataProfileInfo.h b/llvm/include/llvm/Analysis/StaticDataProfileInfo.h index fa21eba..f06e7ce 100644 --- a/llvm/include/llvm/Analysis/StaticDataProfileInfo.h +++ b/llvm/include/llvm/Analysis/StaticDataProfileInfo.h @@ -10,6 +10,24 @@ namespace llvm { +namespace memprof { +// Represents the eligibility status of a global variable for section prefix +// annotation. Other than AnnotationOk, each enum value indicates a specific +// reason for ineligibility. +enum class AnnotationKind : uint8_t { + AnnotationOK, + DeclForLinker, + ExplicitSection, + ReservedName, +}; +/// Returns the annotation kind of the global variable \p GV. +AnnotationKind getAnnotationKind(const GlobalVariable &GV); + +/// Returns true if the annotation kind of the global variable \p GV is +/// AnnotationOK. +bool IsAnnotationOK(const GlobalVariable &GV); +} // namespace memprof + /// A class that holds the constants that represent static data and their /// profile information and provides methods to operate on them. class StaticDataProfileInfo { diff --git a/llvm/include/llvm/CodeGen/ISDOpcodes.h b/llvm/include/llvm/CodeGen/ISDOpcodes.h index c76c83d..ff3dd0d 100644 --- a/llvm/include/llvm/CodeGen/ISDOpcodes.h +++ b/llvm/include/llvm/CodeGen/ISDOpcodes.h @@ -514,6 +514,12 @@ enum NodeType { /// separately rounded operations. FMAD, + /// FMULADD - Performs a * b + c, with, or without, intermediate rounding. + /// It is expected that this will be illegal for most targets, as it usually + /// makes sense to split this or use an FMA. But some targets, such as + /// WebAssembly, can directly support these semantics. + FMULADD, + /// FCOPYSIGN(X, Y) - Return the value of X with the sign of Y. NOTE: This /// DAG node does not require that X and Y have the same type, just that /// they are both floating point. X and the result must have the same type. diff --git a/llvm/include/llvm/CodeGen/SelectionDAG.h b/llvm/include/llvm/CodeGen/SelectionDAG.h index 62c0806..df6ce0f 100644 --- a/llvm/include/llvm/CodeGen/SelectionDAG.h +++ b/llvm/include/llvm/CodeGen/SelectionDAG.h @@ -1850,9 +1850,11 @@ public: /// Get the specified node if it's already available, or else return NULL. LLVM_ABI SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTList, ArrayRef<SDValue> Ops, - const SDNodeFlags Flags); + const SDNodeFlags Flags, + bool AllowCommute = false); LLVM_ABI SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTList, - ArrayRef<SDValue> Ops); + ArrayRef<SDValue> Ops, + bool AllowCommute = false); /// Check if a node exists without modifying its flags. LLVM_ABI bool doesNodeExist(unsigned Opcode, SDVTList VTList, diff --git a/llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h b/llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h index 44ef289..41c3089 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h @@ -51,7 +51,11 @@ public: virtual void reserve(size_t NumBytes, OnReservedFunction OnReserved) = 0; /// Provides working memory - virtual char *prepare(ExecutorAddr Addr, size_t ContentSize) = 0; + /// The LinkGraph parameter is included to allow implementations to allocate + /// working memory from the LinkGraph's allocator, in which case it will be + /// deallocated when the LinkGraph is destroyed. + virtual char *prepare(jitlink::LinkGraph &G, ExecutorAddr Addr, + size_t ContentSize) = 0; using OnInitializedFunction = unique_function<void(Expected<ExecutorAddr>)>; @@ -92,7 +96,8 @@ public: void initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) override; - char *prepare(ExecutorAddr Addr, size_t ContentSize) override; + char *prepare(jitlink::LinkGraph &G, ExecutorAddr Addr, + size_t ContentSize) override; void deinitialize(ArrayRef<ExecutorAddr> Allocations, OnDeinitializedFunction OnDeInitialized) override; @@ -142,7 +147,8 @@ public: void reserve(size_t NumBytes, OnReservedFunction OnReserved) override; - char *prepare(ExecutorAddr Addr, size_t ContentSize) override; + char *prepare(jitlink::LinkGraph &G, ExecutorAddr Addr, + size_t ContentSize) override; void initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) override; diff --git a/llvm/include/llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h b/llvm/include/llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h index a4a7fa4..a5f6c4f 100644 --- a/llvm/include/llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h +++ b/llvm/include/llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h @@ -272,6 +272,9 @@ struct ExecutorAddrRange { } bool contains(ExecutorAddr Addr) const { return Start <= Addr && Addr < End; } + bool contains(const ExecutorAddrRange &Other) { + return (Other.Start >= Start && Other.End <= End); + } bool overlaps(const ExecutorAddrRange &Other) { return !(Other.End <= Start || End <= Other.Start); } diff --git a/llvm/include/llvm/Frontend/OpenMP/OMP.td b/llvm/include/llvm/Frontend/OpenMP/OMP.td index bba0d6e..86a9e24 100644 --- a/llvm/include/llvm/Frontend/OpenMP/OMP.td +++ b/llvm/include/llvm/Frontend/OpenMP/OMP.td @@ -353,6 +353,7 @@ def OMPC_Novariants : Clause<[Spelling<"novariants">]> { } def OMPC_NoWait : Clause<[Spelling<"nowait">]> { let clangClass = "OMPNowaitClause"; + let isValueOptional = true; } def OMP_NUMTASKS_Strict : EnumVal<"strict", 1, 1> {} def OMP_NUMTASKS_Unknown : EnumVal<"unknown", 2, 0> { let isDefault = 1; } diff --git a/llvm/include/llvm/Frontend/OpenMP/OMPKinds.def b/llvm/include/llvm/Frontend/OpenMP/OMPKinds.def index 1694a33..46b3d53 100644 --- a/llvm/include/llvm/Frontend/OpenMP/OMPKinds.def +++ b/llvm/include/llvm/Frontend/OpenMP/OMPKinds.def @@ -472,7 +472,7 @@ __OMP_RTL(__kmpc_target_init, false, Int32, KernelEnvironmentPtr, KernelLaunchEn __OMP_RTL(__kmpc_target_deinit, false, Void,) __OMP_RTL(__kmpc_kernel_prepare_parallel, false, Void, VoidPtr) __OMP_RTL(__kmpc_parallel_51, false, Void, IdentPtr, Int32, Int32, Int32, Int32, - FuncPtrTy, VoidPtr, VoidPtrPtr, SizeTy) + FuncPtrTy, FuncPtrTy, VoidPtrPtr, SizeTy) __OMP_RTL(__kmpc_for_static_loop_4, false, Void, IdentPtr, VoidPtr, VoidPtr, Int32, Int32, Int32, Int8) __OMP_RTL(__kmpc_for_static_loop_4u, false, Void, IdentPtr, VoidPtr, VoidPtr, Int32, Int32, Int32, Int8) __OMP_RTL(__kmpc_for_static_loop_8, false, Void, IdentPtr, VoidPtr, VoidPtr, Int64, Int64, Int64, Int8) diff --git a/llvm/include/llvm/IR/ConstantFPRange.h b/llvm/include/llvm/IR/ConstantFPRange.h index 39dc7c1..e772095 100644 --- a/llvm/include/llvm/IR/ConstantFPRange.h +++ b/llvm/include/llvm/IR/ConstantFPRange.h @@ -230,6 +230,19 @@ public: /// Return a new range representing the possible values resulting /// from a subtraction of a value in this range and a value in \p Other. LLVM_ABI ConstantFPRange sub(const ConstantFPRange &Other) const; + + /// Return a new range representing the possible values resulting + /// from a multiplication of a value in this range and a value in \p Other. + LLVM_ABI ConstantFPRange mul(const ConstantFPRange &Other) const; + + /// Return a new range representing the possible values resulting + /// from a division of a value in this range and a value in + /// \p Other. + LLVM_ABI ConstantFPRange div(const ConstantFPRange &Other) const; + + /// Flush denormal values to zero according to the specified mode. + /// For dynamic mode, we return the union of all possible results. + LLVM_ABI void flushDenormals(DenormalMode::DenormalModeKind Mode); }; inline raw_ostream &operator<<(raw_ostream &OS, const ConstantFPRange &CR) { diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h index 041a4ce..dacda0a 100644 --- a/llvm/include/llvm/IR/IRBuilder.h +++ b/llvm/include/llvm/IR/IRBuilder.h @@ -2548,6 +2548,11 @@ public: std::optional<RoundingMode> Rounding = std::nullopt, std::optional<fp::ExceptionBehavior> Except = std::nullopt); + LLVM_ABI Value *CreateSelectWithUnknownProfile(Value *C, Value *True, + Value *False, + StringRef PassName, + const Twine &Name = ""); + LLVM_ABI Value *CreateSelect(Value *C, Value *True, Value *False, const Twine &Name = "", Instruction *MDFrom = nullptr); diff --git a/llvm/include/llvm/IR/IntrinsicsRISCVXsf.td b/llvm/include/llvm/IR/IntrinsicsRISCVXsf.td index bf20080..4a0272c 100644 --- a/llvm/include/llvm/IR/IntrinsicsRISCVXsf.td +++ b/llvm/include/llvm/IR/IntrinsicsRISCVXsf.td @@ -180,4 +180,98 @@ let TargetPrefix = "riscv" in { // XSfvfnrclipxfqf defm int_riscv_sf_vfnrclip_x_f_qf : RISCVSFCustomVFNRCLIP; defm int_riscv_sf_vfnrclip_xu_f_qf : RISCVSFCustomVFNRCLIP; + + // XSfmm + // Output: (output_len) + // Input: (input_len, vsew, twiden) + class RISCVSFVSet + : DefaultAttrsIntrinsic<[llvm_anyint_ty], + [LLVMMatchType<0>, LLVMMatchType<0>, LLVMMatchType<0>], + [ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>, IntrNoMem]>; + + // Input: (tss, base, tn) + class RISCVSFTileLoad + : DefaultAttrsIntrinsic<[], + [llvm_anyint_ty, llvm_ptr_ty, LLVMMatchType<0>], + [NoCapture<ArgIndex<1>>, IntrHasSideEffects]>, + RISCVVIntrinsic; + + // Input: (tss, base, tn) + class RISCVSFTileStore + : DefaultAttrsIntrinsic<[], + [llvm_anyint_ty, llvm_ptr_ty, LLVMMatchType<0>], + [NoCapture<ArgIndex<1>>, IntrWriteMem, + IntrHasSideEffects]>, + RISCVVIntrinsic; + + // Output: () + // Input: (mtd, mat1, mat2, tm, tn, tk, twiden) + class RISCVSFCustomMatMul<bit is_float = false> + : DefaultAttrsIntrinsic<[], [llvm_anyint_ty, llvm_anyvector_ty, + !if(is_float, LLVMMatchType<1>, + llvm_anyvector_ty), + LLVMMatchType<0>, LLVMMatchType<0>, + LLVMMatchType<0>, LLVMMatchType<0>], + [IntrNoMem, IntrHasSideEffects, + ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<6>>]>, + RISCVVIntrinsic; + + def int_riscv_sf_vsettnt : RISCVSFVSet; + def int_riscv_sf_vsettm : RISCVSFVSet; + def int_riscv_sf_vsettk : RISCVSFVSet; + + def int_riscv_sf_vlte8 : RISCVSFTileLoad; + def int_riscv_sf_vlte16 : RISCVSFTileLoad; + def int_riscv_sf_vlte32 : RISCVSFTileLoad; + def int_riscv_sf_vlte64 : RISCVSFTileLoad; + def int_riscv_sf_vste8 : RISCVSFTileStore; + def int_riscv_sf_vste16 : RISCVSFTileStore; + def int_riscv_sf_vste32 : RISCVSFTileStore; + def int_riscv_sf_vste64 : RISCVSFTileStore; + + // Output: (vd) + // Input: (tss, tn) + def int_riscv_sf_vtmv_v_t + : DefaultAttrsIntrinsic<[llvm_anyvector_ty], + [llvm_anyint_ty, LLVMMatchType<1>], + [IntrNoMem, IntrHasSideEffects]>, + RISCVVIntrinsic { + let VLOperand = 2; + } + // Output: () + // Input: (tss, vs2, tn) + def int_riscv_sf_vtmv_t_v + : DefaultAttrsIntrinsic<[], [LLVMMatchType<1>, llvm_anyvector_ty, + llvm_anyint_ty], [IntrNoMem, IntrHasSideEffects]>, + RISCVVIntrinsic { + let VLOperand = 2; + } + + foreach a = ["u", "s"] in { + foreach b = ["u", "s"] in { + def int_riscv_sf_mm_ # a # _ # b : RISCVSFCustomMatMul; + } + } + + def int_riscv_sf_mm_f_f : RISCVSFCustomMatMul<true>; + foreach e1 = [5, 4] in + foreach e2 = [5, 4] in + def int_riscv_sf_mm_e # e1 # m # !sub(7, e1) # _e # e2 # m # !sub(7, e2) + : RISCVSFCustomMatMul<true>; + + // Output: () + // Input: (mtd) + def int_riscv_sf_vtzero_t + : DefaultAttrsIntrinsic<[], + [llvm_anyint_ty, LLVMMatchType<0>,LLVMMatchType<0>, + LLVMMatchType<0>, LLVMMatchType<0>], + [ImmArg<ArgIndex<0>>, ImmArg<ArgIndex<3>>, + ImmArg<ArgIndex<4>>, IntrNoMem, IntrHasSideEffects]>, + RISCVVIntrinsic; + + // Output: () + // Input: () + def int_riscv_sf_vtdiscard + : DefaultAttrsIntrinsic<[], [], [IntrNoMem, IntrHasSideEffects]>, + RISCVVIntrinsic; } // TargetPrefix = "riscv" diff --git a/llvm/include/llvm/Support/BinaryStreamWriter.h b/llvm/include/llvm/Support/BinaryStreamWriter.h index dddf53b..39ce0b6 100644 --- a/llvm/include/llvm/Support/BinaryStreamWriter.h +++ b/llvm/include/llvm/Support/BinaryStreamWriter.h @@ -10,6 +10,7 @@ #define LLVM_SUPPORT_BINARYSTREAMWRITER_H #include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/STLForwardCompat.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/BinaryStreamArray.h" #include "llvm/Support/BinaryStreamError.h" @@ -69,8 +70,7 @@ public: static_assert(std::is_enum<T>::value, "Cannot call writeEnum with non-Enum type"); - using U = std::underlying_type_t<T>; - return writeInteger<U>(static_cast<U>(Num)); + return writeInteger(llvm::to_underlying(Num)); } /// Write the unsigned integer Value to the underlying stream using ULEB128 diff --git a/llvm/include/llvm/Support/DebugCounter.h b/llvm/include/llvm/Support/DebugCounter.h index 48fc600..39a08d4 100644 --- a/llvm/include/llvm/Support/DebugCounter.h +++ b/llvm/include/llvm/Support/DebugCounter.h @@ -178,6 +178,7 @@ protected: std::string Desc; SmallVector<Chunk> Chunks; }; + bool handleCounterIncrement(CounterInfo &Info); DenseMap<unsigned, CounterInfo> Counters; CounterVector RegisteredCounters; @@ -188,6 +189,8 @@ protected: bool ShouldPrintCounter = false; + bool ShouldPrintCounterQueries = false; + bool BreakOnLast = false; }; diff --git a/llvm/include/llvm/Support/Format.h b/llvm/include/llvm/Support/Format.h index 34b224d..b549341 100644 --- a/llvm/include/llvm/Support/Format.h +++ b/llvm/include/llvm/Support/Format.h @@ -78,9 +78,20 @@ public: /// printed, this synthesizes the string into a temporary buffer provided and /// returns whether or not it is big enough. +namespace detail { +template <typename T> struct decay_if_c_char_array { + using type = T; +}; +template <std::size_t N> struct decay_if_c_char_array<char[N]> { + using type = const char *; +}; +template <typename T> +using decay_if_c_char_array_t = typename decay_if_c_char_array<T>::type; +} // namespace detail + template <typename... Ts> class format_object final : public format_object_base { - std::tuple<Ts...> Vals; + std::tuple<detail::decay_if_c_char_array_t<Ts>...> Vals; template <std::size_t... Is> int snprint_tuple(char *Buffer, unsigned BufferSize, @@ -96,7 +107,7 @@ public: format_object(const char *fmt, const Ts &... vals) : format_object_base(fmt), Vals(vals...) { static_assert( - (std::is_scalar_v<Ts> && ...), + (std::is_scalar_v<detail::decay_if_c_char_array_t<Ts>> && ...), "format can't be used with non fundamental / non pointer type"); } diff --git a/llvm/include/llvm/Support/ScopedPrinter.h b/llvm/include/llvm/Support/ScopedPrinter.h index 94080e8..7b87fda 100644 --- a/llvm/include/llvm/Support/ScopedPrinter.h +++ b/llvm/include/llvm/Support/ScopedPrinter.h @@ -11,6 +11,7 @@ #include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/STLForwardCompat.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringRef.h" @@ -57,8 +58,7 @@ struct HexNumber { HexNumber(unsigned long Value) : Value(Value) {} HexNumber(unsigned long long Value) : Value(Value) {} template <typename EnumT, typename = std::enable_if_t<std::is_enum_v<EnumT>>> - HexNumber(EnumT Value) - : HexNumber(static_cast<std::underlying_type_t<EnumT>>(Value)) {} + HexNumber(EnumT Value) : HexNumber(llvm::to_underlying(Value)) {} uint64_t Value; }; @@ -84,7 +84,7 @@ struct FlagEntry { : Name(Name), Value(Value) {} template <typename EnumT, typename = std::enable_if_t<std::is_enum_v<EnumT>>> FlagEntry(StringRef Name, EnumT Value) - : FlagEntry(Name, static_cast<std::underlying_type_t<EnumT>>(Value)) {} + : FlagEntry(Name, llvm::to_underlying(Value)) {} StringRef Name; uint64_t Value; diff --git a/llvm/include/llvm/Support/SpecialCaseList.h b/llvm/include/llvm/Support/SpecialCaseList.h index 466e2a4..ead7655 100644 --- a/llvm/include/llvm/Support/SpecialCaseList.h +++ b/llvm/include/llvm/Support/SpecialCaseList.h @@ -115,7 +115,8 @@ protected: // classes. LLVM_ABI bool createInternal(const std::vector<std::string> &Paths, vfs::FileSystem &VFS, std::string &Error); - LLVM_ABI bool createInternal(const MemoryBuffer *MB, std::string &Error); + LLVM_ABI bool createInternal(const MemoryBuffer *MB, std::string &Error, + bool OrderBySize = false); SpecialCaseList() = default; SpecialCaseList(SpecialCaseList const &) = delete; @@ -126,6 +127,8 @@ private: class RegexMatcher { public: LLVM_ABI Error insert(StringRef Pattern, unsigned LineNumber); + LLVM_ABI void preprocess(bool BySize); + LLVM_ABI void match(StringRef Query, llvm::function_ref<void(StringRef Rule, unsigned LineNo)> Cb) const; @@ -144,6 +147,8 @@ private: class GlobMatcher { public: LLVM_ABI Error insert(StringRef Pattern, unsigned LineNumber); + LLVM_ABI void preprocess(bool BySize); + LLVM_ABI void match(StringRef Query, llvm::function_ref<void(StringRef Rule, unsigned LineNo)> Cb) const; @@ -164,6 +169,9 @@ private: public: LLVM_ABI Matcher(bool UseGlobs, bool RemoveDotSlash); + LLVM_ABI Error insert(StringRef Pattern, unsigned LineNumber); + LLVM_ABI void preprocess(bool BySize); + LLVM_ABI void match(StringRef Query, llvm::function_ref<void(StringRef Rule, unsigned LineNo)> Cb) const; @@ -174,8 +182,6 @@ private: return R; } - LLVM_ABI Error insert(StringRef Pattern, unsigned LineNumber); - std::variant<RegexMatcher, GlobMatcher> M; bool RemoveDotSlash; }; @@ -206,6 +212,8 @@ protected: StringRef Category) const; private: + friend class SpecialCaseList; + LLVM_ABI void preprocess(bool OrderBySize); LLVM_ABI const SpecialCaseList::Matcher * findMatcher(StringRef Prefix, StringRef Category) const; }; @@ -222,7 +230,7 @@ private: /// Parses just-constructed SpecialCaseList entries from a memory buffer. LLVM_ABI bool parse(unsigned FileIdx, const MemoryBuffer *MB, - std::string &Error); + std::string &Error, bool OrderBySize); }; } // namespace llvm diff --git a/llvm/include/llvm/TableGen/CodeGenHelpers.h b/llvm/include/llvm/TableGen/CodeGenHelpers.h index 7dca6a0..5b823db 100644 --- a/llvm/include/llvm/TableGen/CodeGenHelpers.h +++ b/llvm/include/llvm/TableGen/CodeGenHelpers.h @@ -38,28 +38,35 @@ private: // namespace (empty for anonymous namespace) or nested namespace. class NamespaceEmitter { public: - NamespaceEmitter(raw_ostream &OS, StringRef Name) : OS(OS) { - emitNamespaceStarts(Name); + NamespaceEmitter(raw_ostream &OS, StringRef Name) + : Name(trim(Name).str()), OS(OS) { + OS << "namespace " << this->Name << " {\n"; } ~NamespaceEmitter() { close(); } // Explicit function to close the namespace scopes. void close() { - for (StringRef NS : llvm::reverse(Namespaces)) - OS << "} // namespace " << NS << "\n"; - Namespaces.clear(); + if (!Closed) + OS << "} // namespace " << Name << "\n"; + Closed = true; } private: - void emitNamespaceStarts(StringRef Name) { - llvm::SplitString(Name, Namespaces, "::"); - for (StringRef NS : Namespaces) - OS << "namespace " << NS << " {\n"; + // Trim "::" prefix. If the namespace specified is ""::mlir::toy", then the + // generated namespace scope needs to use + // + // namespace mlir::toy { + // } + // + // and cannot use "namespace ::mlir::toy". + static StringRef trim(StringRef Name) { + Name.consume_front("::"); + return Name; } - - SmallVector<StringRef, 2> Namespaces; + std::string Name; raw_ostream &OS; + bool Closed = false; }; } // end namespace llvm diff --git a/llvm/include/llvm/Target/TargetSelectionDAG.td b/llvm/include/llvm/Target/TargetSelectionDAG.td index 632be7a..07a858f 100644 --- a/llvm/include/llvm/Target/TargetSelectionDAG.td +++ b/llvm/include/llvm/Target/TargetSelectionDAG.td @@ -535,6 +535,7 @@ def fdiv : SDNode<"ISD::FDIV" , SDTFPBinOp>; def frem : SDNode<"ISD::FREM" , SDTFPBinOp>; def fma : SDNode<"ISD::FMA" , SDTFPTernaryOp, [SDNPCommutative]>; def fmad : SDNode<"ISD::FMAD" , SDTFPTernaryOp, [SDNPCommutative]>; +def fmuladd : SDNode<"ISD::FMULADD" , SDTFPTernaryOp, [SDNPCommutative]>; def fabs : SDNode<"ISD::FABS" , SDTFPUnaryOp>; def fminnum : SDNode<"ISD::FMINNUM" , SDTFPBinOp, [SDNPCommutative, SDNPAssociative]>; diff --git a/llvm/include/llvm/TargetParser/RISCVTargetParser.h b/llvm/include/llvm/TargetParser/RISCVTargetParser.h index b1fca55..2ac58a5 100644 --- a/llvm/include/llvm/TargetParser/RISCVTargetParser.h +++ b/llvm/include/llvm/TargetParser/RISCVTargetParser.h @@ -161,6 +161,8 @@ inline static bool isAltFmt(unsigned VType) { return VType & 0x100; } LLVM_ABI void printVType(unsigned VType, raw_ostream &OS); +LLVM_ABI void printXSfmmVType(unsigned VType, raw_ostream &OS); + LLVM_ABI unsigned getSEWLMULRatio(unsigned SEW, VLMUL VLMul); LLVM_ABI std::optional<VLMUL> getSameRatioLMUL(unsigned SEW, VLMUL VLMUL, diff --git a/llvm/include/llvm/Transforms/Coroutines/MaterializationUtils.h b/llvm/include/llvm/Transforms/Coroutines/MaterializationUtils.h index 558984f..eb2b34d 100644 --- a/llvm/include/llvm/Transforms/Coroutines/MaterializationUtils.h +++ b/llvm/include/llvm/Transforms/Coroutines/MaterializationUtils.h @@ -12,9 +12,7 @@ #ifndef LLVM_TRANSFORMS_COROUTINES_MATERIALIZATIONUTILS_H #define LLVM_TRANSFORMS_COROUTINES_MATERIALIZATIONUTILS_H -namespace llvm { - -namespace coro { +namespace llvm::coro { // True if I is trivially rematerialzable, e.g. InsertElementInst LLVM_ABI bool isTriviallyMaterializable(Instruction &I); @@ -24,8 +22,6 @@ LLVM_ABI void doRematerializations(Function &F, SuspendCrossingInfo &Checker, std::function<bool(Instruction &)> IsMaterializable); -} // namespace coro - -} // namespace llvm +} // namespace llvm::coro #endif // LLVM_TRANSFORMS_COROUTINES_MATERIALIZATIONUTILS_H diff --git a/llvm/include/llvm/Transforms/Coroutines/SpillUtils.h b/llvm/include/llvm/Transforms/Coroutines/SpillUtils.h index 6cdf83c0..356f9ca 100644 --- a/llvm/include/llvm/Transforms/Coroutines/SpillUtils.h +++ b/llvm/include/llvm/Transforms/Coroutines/SpillUtils.h @@ -13,9 +13,7 @@ #ifndef LLVM_TRANSFORMS_COROUTINES_SPILLINGINFO_H #define LLVM_TRANSFORMS_COROUTINES_SPILLINGINFO_H -namespace llvm { - -namespace coro { +namespace llvm::coro { using SpillInfo = SmallMapVector<Value *, SmallVector<Instruction *, 2>, 8>; @@ -38,6 +36,7 @@ void collectSpillsAndAllocasFromInsts( SmallVector<CoroAllocaAllocInst *, 4> &LocalAllocas, Function &F, const SuspendCrossingInfo &Checker, const DominatorTree &DT, const coro::Shape &Shape); + void collectSpillsFromDbgInfo(SpillInfo &Spills, Function &F, const SuspendCrossingInfo &Checker); @@ -52,8 +51,6 @@ void sinkSpillUsesAfterCoroBegin(const DominatorTree &DT, BasicBlock::iterator getSpillInsertionPt(const coro::Shape &, Value *Def, const DominatorTree &DT); -} // namespace coro - -} // namespace llvm +} // namespace llvm::coro #endif // LLVM_TRANSFORMS_COROUTINES_SPILLINGINFO_H diff --git a/llvm/include/llvm/Transforms/Utils/SSAUpdaterBulk.h b/llvm/include/llvm/Transforms/Utils/SSAUpdaterBulk.h index 48e8c86..2db3f6d4 100644 --- a/llvm/include/llvm/Transforms/Utils/SSAUpdaterBulk.h +++ b/llvm/include/llvm/Transforms/Utils/SSAUpdaterBulk.h @@ -13,7 +13,6 @@ #ifndef LLVM_TRANSFORMS_UTILS_SSAUPDATERBULK_H #define LLVM_TRANSFORMS_UTILS_SSAUPDATERBULK_H -#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/IR/PredIteratorCache.h" #include "llvm/Support/Compiler.h" @@ -79,6 +78,10 @@ public: LLVM_ABI void RewriteAllUses(DominatorTree *DT, SmallVectorImpl<PHINode *> *InsertedPHIs = nullptr); + + /// Rewrite all uses and simplify the inserted PHI nodes. + /// Use this method to preserve behavior when replacing SSAUpdater. + void RewriteAndOptimizeAllUses(DominatorTree &DT); }; } // end namespace llvm diff --git a/llvm/include/llvm/XRay/BlockIndexer.h b/llvm/include/llvm/XRay/BlockIndexer.h index e9782da..155e6bd 100644 --- a/llvm/include/llvm/XRay/BlockIndexer.h +++ b/llvm/include/llvm/XRay/BlockIndexer.h @@ -19,8 +19,7 @@ #include <cstdint> #include <vector> -namespace llvm { -namespace xray { +namespace llvm::xray { // The BlockIndexer will gather all related records associated with a // process+thread and group them by 'Block'. @@ -63,7 +62,6 @@ public: Error flush(); }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_BLOCKINDEXER_H diff --git a/llvm/include/llvm/XRay/BlockPrinter.h b/llvm/include/llvm/XRay/BlockPrinter.h index caf78c5..81944a5 100644 --- a/llvm/include/llvm/XRay/BlockPrinter.h +++ b/llvm/include/llvm/XRay/BlockPrinter.h @@ -18,8 +18,7 @@ #include "llvm/XRay/FDRRecords.h" #include "llvm/XRay/RecordPrinter.h" -namespace llvm { -namespace xray { +namespace llvm::xray { class LLVM_ABI BlockPrinter : public RecordVisitor { enum class State { @@ -55,7 +54,6 @@ public: void reset() { CurrentState = State::Start; } }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_BLOCKPRINTER_H diff --git a/llvm/include/llvm/XRay/BlockVerifier.h b/llvm/include/llvm/XRay/BlockVerifier.h index b88785c..5e7b25c 100644 --- a/llvm/include/llvm/XRay/BlockVerifier.h +++ b/llvm/include/llvm/XRay/BlockVerifier.h @@ -16,8 +16,7 @@ #include "llvm/Support/Compiler.h" #include "llvm/XRay/FDRRecords.h" -namespace llvm { -namespace xray { +namespace llvm::xray { class LLVM_ABI BlockVerifier : public RecordVisitor { public: @@ -64,7 +63,6 @@ public: void reset(); }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_BLOCKVERIFIER_H diff --git a/llvm/include/llvm/XRay/FDRLogBuilder.h b/llvm/include/llvm/XRay/FDRLogBuilder.h index f07c446..5f7b815 100644 --- a/llvm/include/llvm/XRay/FDRLogBuilder.h +++ b/llvm/include/llvm/XRay/FDRLogBuilder.h @@ -10,8 +10,7 @@ #include "llvm/XRay/FDRRecords.h" -namespace llvm { -namespace xray { +namespace llvm::xray { /// The LogBuilder class allows for creating ad-hoc collections of records /// through the `add<...>(...)` function. An example use of this API is in @@ -34,7 +33,6 @@ public: std::vector<std::unique_ptr<Record>> consume() { return std::move(Records); } }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_FDRLOGBUILDER_H diff --git a/llvm/include/llvm/XRay/FDRRecordConsumer.h b/llvm/include/llvm/XRay/FDRRecordConsumer.h index 473777f..13bb711 100644 --- a/llvm/include/llvm/XRay/FDRRecordConsumer.h +++ b/llvm/include/llvm/XRay/FDRRecordConsumer.h @@ -15,8 +15,7 @@ #include <memory> #include <vector> -namespace llvm { -namespace xray { +namespace llvm::xray { class RecordConsumer { public: @@ -48,7 +47,6 @@ public: Error consume(std::unique_ptr<Record> R) override; }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_FDRRECORDCONSUMER_H diff --git a/llvm/include/llvm/XRay/FDRRecordProducer.h b/llvm/include/llvm/XRay/FDRRecordProducer.h index 083b571..b953f62 100644 --- a/llvm/include/llvm/XRay/FDRRecordProducer.h +++ b/llvm/include/llvm/XRay/FDRRecordProducer.h @@ -14,8 +14,7 @@ #include "llvm/XRay/XRayRecord.h" #include <memory> -namespace llvm { -namespace xray { +namespace llvm::xray { class RecordProducer { public: @@ -45,7 +44,6 @@ public: Expected<std::unique_ptr<Record>> produce() override; }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_FDRRECORDPRODUCER_H diff --git a/llvm/include/llvm/XRay/FDRRecords.h b/llvm/include/llvm/XRay/FDRRecords.h index 7ee8db6..91689cae 100644 --- a/llvm/include/llvm/XRay/FDRRecords.h +++ b/llvm/include/llvm/XRay/FDRRecords.h @@ -23,8 +23,7 @@ #include "llvm/Support/Error.h" #include "llvm/XRay/XRayRecord.h" -namespace llvm { -namespace xray { +namespace llvm::xray { class RecordVisitor; class RecordInitializer; @@ -444,7 +443,6 @@ public: Error visit(TypedEventRecord &) override; }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_FDRRECORDS_H diff --git a/llvm/include/llvm/XRay/FDRTraceExpander.h b/llvm/include/llvm/XRay/FDRTraceExpander.h index 197c123..ca400c9 100644 --- a/llvm/include/llvm/XRay/FDRTraceExpander.h +++ b/llvm/include/llvm/XRay/FDRTraceExpander.h @@ -17,8 +17,7 @@ #include "llvm/XRay/FDRRecords.h" #include "llvm/XRay/XRayRecord.h" -namespace llvm { -namespace xray { +namespace llvm::xray { class TraceExpander : public RecordVisitor { // Type-erased callback for handling individual XRayRecord instances. @@ -56,7 +55,6 @@ public: Error flush(); }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_FDRTRACEEXPANDER_H diff --git a/llvm/include/llvm/XRay/FDRTraceWriter.h b/llvm/include/llvm/XRay/FDRTraceWriter.h index a3dc58e..957039d 100644 --- a/llvm/include/llvm/XRay/FDRTraceWriter.h +++ b/llvm/include/llvm/XRay/FDRTraceWriter.h @@ -18,8 +18,7 @@ #include "llvm/XRay/FDRRecords.h" #include "llvm/XRay/XRayRecord.h" -namespace llvm { -namespace xray { +namespace llvm::xray { /// The FDRTraceWriter allows us to hand-craft an XRay Flight Data Recorder /// (FDR) mode log file. This is used primarily for testing, generating @@ -50,7 +49,6 @@ private: support::endian::Writer OS; }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_FDRTRACEWRITER_H diff --git a/llvm/include/llvm/XRay/FileHeaderReader.h b/llvm/include/llvm/XRay/FileHeaderReader.h index ecdb975..758ca29 100644 --- a/llvm/include/llvm/XRay/FileHeaderReader.h +++ b/llvm/include/llvm/XRay/FileHeaderReader.h @@ -19,15 +19,13 @@ #include "llvm/XRay/XRayRecord.h" #include <cstdint> -namespace llvm { -namespace xray { +namespace llvm::xray { /// Convenience function for loading the file header given a data extractor at a /// specified offset. LLVM_ABI Expected<XRayFileHeader> readBinaryFormatHeader(DataExtractor &HeaderExtractor, uint64_t &OffsetPtr); -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_FILEHEADERREADER_H diff --git a/llvm/include/llvm/XRay/Graph.h b/llvm/include/llvm/XRay/Graph.h index 07b418b..8521e09 100644 --- a/llvm/include/llvm/XRay/Graph.h +++ b/llvm/include/llvm/XRay/Graph.h @@ -23,8 +23,7 @@ #include "llvm/ADT/iterator.h" #include "llvm/Support/Error.h" -namespace llvm { -namespace xray { +namespace llvm::xray { /// A Graph object represents a Directed Graph and is used in XRay to compute /// and store function call graphs and associated statistical information. @@ -485,6 +484,6 @@ public: return p; } }; -} -} +} // namespace llvm::xray + #endif diff --git a/llvm/include/llvm/XRay/InstrumentationMap.h b/llvm/include/llvm/XRay/InstrumentationMap.h index b5371478..c5e7ebf 100644 --- a/llvm/include/llvm/XRay/InstrumentationMap.h +++ b/llvm/include/llvm/XRay/InstrumentationMap.h @@ -23,9 +23,7 @@ #include <unordered_map> #include <vector> -namespace llvm { - -namespace xray { +namespace llvm::xray { // Forward declare to make a friend. class InstrumentationMap; @@ -102,11 +100,11 @@ public: const SledContainer &sleds() const { return Sleds; }; }; -} // end namespace xray - -namespace yaml { +} // end namespace llvm::xray -template <> struct ScalarEnumerationTraits<xray::SledEntry::FunctionKinds> { +namespace llvm { +template <> +struct yaml::ScalarEnumerationTraits<xray::SledEntry::FunctionKinds> { static void enumeration(IO &IO, xray::SledEntry::FunctionKinds &Kind) { IO.enumCase(Kind, "function-enter", xray::SledEntry::FunctionKinds::ENTRY); IO.enumCase(Kind, "function-exit", xray::SledEntry::FunctionKinds::EXIT); @@ -118,7 +116,7 @@ template <> struct ScalarEnumerationTraits<xray::SledEntry::FunctionKinds> { } }; -template <> struct MappingTraits<xray::YAMLXRaySledEntry> { +template <> struct yaml::MappingTraits<xray::YAMLXRaySledEntry> { static void mapping(IO &IO, xray::YAMLXRaySledEntry &Entry) { IO.mapRequired("id", Entry.FuncId); IO.mapRequired("address", Entry.Address); @@ -131,10 +129,7 @@ template <> struct MappingTraits<xray::YAMLXRaySledEntry> { static constexpr bool flow = true; }; - -} // end namespace yaml - -} // end namespace llvm +} // namespace llvm LLVM_YAML_IS_SEQUENCE_VECTOR(xray::YAMLXRaySledEntry) diff --git a/llvm/include/llvm/XRay/Profile.h b/llvm/include/llvm/XRay/Profile.h index e30c01e..b5b8dd2 100644 --- a/llvm/include/llvm/XRay/Profile.h +++ b/llvm/include/llvm/XRay/Profile.h @@ -22,8 +22,7 @@ #include <utility> #include <vector> -namespace llvm { -namespace xray { +namespace llvm::xray { class Profile; @@ -144,7 +143,6 @@ public: bool empty() const { return Blocks.empty(); } }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif diff --git a/llvm/include/llvm/XRay/RecordPrinter.h b/llvm/include/llvm/XRay/RecordPrinter.h index 5d2c277..3281221 100644 --- a/llvm/include/llvm/XRay/RecordPrinter.h +++ b/llvm/include/llvm/XRay/RecordPrinter.h @@ -17,8 +17,7 @@ #include "llvm/Support/raw_ostream.h" #include "llvm/XRay/FDRRecords.h" -namespace llvm { -namespace xray { +namespace llvm::xray { class LLVM_ABI RecordPrinter : public RecordVisitor { raw_ostream &OS; @@ -44,7 +43,6 @@ public: Error visit(TypedEventRecord &) override; }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_RECORDPRINTER_H diff --git a/llvm/include/llvm/XRay/Trace.h b/llvm/include/llvm/XRay/Trace.h index 5e4e40a..13ada22 100644 --- a/llvm/include/llvm/XRay/Trace.h +++ b/llvm/include/llvm/XRay/Trace.h @@ -21,8 +21,7 @@ #include "llvm/Support/Error.h" #include "llvm/XRay/XRayRecord.h" -namespace llvm { -namespace xray { +namespace llvm::xray { /// A Trace object represents the records that have been loaded from XRay /// log files generated by instrumented binaries. We encapsulate the logic of @@ -76,7 +75,6 @@ LLVM_ABI Expected<Trace> loadTraceFile(StringRef Filename, bool Sort = false); LLVM_ABI Expected<Trace> loadTrace(const DataExtractor &Extractor, bool Sort = false); -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_TRACE_H diff --git a/llvm/include/llvm/XRay/XRayRecord.h b/llvm/include/llvm/XRay/XRayRecord.h index 238bf3d..8f3440c 100644 --- a/llvm/include/llvm/XRay/XRayRecord.h +++ b/llvm/include/llvm/XRay/XRayRecord.h @@ -18,8 +18,7 @@ #include <vector> #include <string> -namespace llvm { -namespace xray { +namespace llvm::xray { /// XRay traces all have a header providing some top-matter information useful /// to help tools determine how to interpret the information available in the @@ -98,7 +97,6 @@ struct XRayRecord { std::string Data; }; -} // namespace xray -} // namespace llvm +} // namespace llvm::xray #endif // LLVM_XRAY_XRAYRECORD_H diff --git a/llvm/include/llvm/XRay/YAMLXRayRecord.h b/llvm/include/llvm/XRay/YAMLXRayRecord.h index 6062606..6bf4f1d 100644 --- a/llvm/include/llvm/XRay/YAMLXRayRecord.h +++ b/llvm/include/llvm/XRay/YAMLXRayRecord.h @@ -17,8 +17,7 @@ #include "llvm/Support/YAMLTraits.h" #include "llvm/XRay/XRayRecord.h" -namespace llvm { -namespace xray { +namespace llvm::xray { struct YAMLXRayFileHeader { uint16_t Version; @@ -46,13 +45,12 @@ struct YAMLXRayTrace { std::vector<YAMLXRayRecord> Records; }; -} // namespace xray - -namespace yaml { +} // namespace llvm::xray +namespace llvm { // YAML Traits // ----------- -template <> struct ScalarEnumerationTraits<xray::RecordTypes> { +template <> struct yaml::ScalarEnumerationTraits<xray::RecordTypes> { static void enumeration(IO &IO, xray::RecordTypes &Type) { IO.enumCase(Type, "function-enter", xray::RecordTypes::ENTER); IO.enumCase(Type, "function-exit", xray::RecordTypes::EXIT); @@ -63,7 +61,7 @@ template <> struct ScalarEnumerationTraits<xray::RecordTypes> { } }; -template <> struct MappingTraits<xray::YAMLXRayFileHeader> { +template <> struct yaml::MappingTraits<xray::YAMLXRayFileHeader> { static void mapping(IO &IO, xray::YAMLXRayFileHeader &Header) { IO.mapRequired("version", Header.Version); IO.mapRequired("type", Header.Type); @@ -73,7 +71,7 @@ template <> struct MappingTraits<xray::YAMLXRayFileHeader> { } }; -template <> struct MappingTraits<xray::YAMLXRayRecord> { +template <> struct yaml::MappingTraits<xray::YAMLXRayRecord> { static void mapping(IO &IO, xray::YAMLXRayRecord &Record) { IO.mapRequired("type", Record.RecordType); IO.mapOptional("func-id", Record.FuncId); @@ -90,7 +88,7 @@ template <> struct MappingTraits<xray::YAMLXRayRecord> { static constexpr bool flow = true; }; -template <> struct MappingTraits<xray::YAMLXRayTrace> { +template <> struct yaml::MappingTraits<llvm::xray::YAMLXRayTrace> { static void mapping(IO &IO, xray::YAMLXRayTrace &Trace) { // A trace file contains two parts, the header and the list of all the // trace records. @@ -98,8 +96,6 @@ template <> struct MappingTraits<xray::YAMLXRayTrace> { IO.mapRequired("records", Trace.Records); } }; - -} // namespace yaml } // namespace llvm LLVM_YAML_IS_SEQUENCE_VECTOR(xray::YAMLXRayRecord) |