diff options
Diffstat (limited to 'contrib/llvm-project/clang/lib/Basic')
55 files changed, 1580 insertions, 883 deletions
diff --git a/contrib/llvm-project/clang/lib/Basic/ASTSourceDescriptor.cpp b/contrib/llvm-project/clang/lib/Basic/ASTSourceDescriptor.cpp new file mode 100644 index 000000000000..8072c08a51d3 --- /dev/null +++ b/contrib/llvm-project/clang/lib/Basic/ASTSourceDescriptor.cpp @@ -0,0 +1,33 @@ +//===- ASTSourceDescriptor.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 +// +//===----------------------------------------------------------------------===// +// +/// Defines the clang::ASTSourceDescriptor class, which abstracts clang modules +/// and precompiled header files +// +//===----------------------------------------------------------------------===// + +#include "clang/Basic/ASTSourceDescriptor.h" + +namespace clang { + +ASTSourceDescriptor::ASTSourceDescriptor(Module &M) + : Signature(M.Signature), ClangModule(&M) { + if (M.Directory) + Path = M.Directory->getName(); + if (auto File = M.getASTFile()) + ASTFile = File->getName(); +} + +std::string ASTSourceDescriptor::getModuleName() const { + if (ClangModule) + return ClangModule->Name; + else + return std::string(PCHModuleName); +} + +} // namespace clang diff --git a/contrib/llvm-project/clang/lib/Basic/Attributes.cpp b/contrib/llvm-project/clang/lib/Basic/Attributes.cpp index 44a4f1890d39..867d241a2cf8 100644 --- a/contrib/llvm-project/clang/lib/Basic/Attributes.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Attributes.cpp @@ -47,8 +47,12 @@ int clang::hasAttribute(AttributeCommonInfo::Syntax Syntax, // attributes. We support those, but not through the typical attribute // machinery that goes through TableGen. We support this in all OpenMP modes // so long as double square brackets are enabled. - if (LangOpts.OpenMP && ScopeName == "omp") - return (Name == "directive" || Name == "sequence") ? 1 : 0; + // + // Other OpenMP attributes (e.g. [[omp::assume]]) are handled via the + // regular attribute parsing machinery. + if (LangOpts.OpenMP && ScopeName == "omp" && + (Name == "directive" || Name == "sequence")) + return 1; int res = hasAttributeImpl(Syntax, Name, ScopeName, Target, LangOpts); if (res) diff --git a/contrib/llvm-project/clang/lib/Basic/Builtins.cpp b/contrib/llvm-project/clang/lib/Basic/Builtins.cpp index d366989bafc5..7116e27cd954 100644 --- a/contrib/llvm-project/clang/lib/Basic/Builtins.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Builtins.cpp @@ -38,7 +38,7 @@ static constexpr Builtin::Info BuiltinInfo[] = { {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANGS}, #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, LANGS) \ {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, LANGS}, -#include "clang/Basic/Builtins.def" +#include "clang/Basic/Builtins.inc" }; const Builtin::Info &Builtin::Context::getRecord(unsigned ID) const { @@ -64,7 +64,7 @@ bool Builtin::Context::isBuiltinFunc(llvm::StringRef FuncName) { bool InStdNamespace = FuncName.consume_front("std-"); for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin; ++i) { - if (FuncName.equals(BuiltinInfo[i].Name) && + if (FuncName == BuiltinInfo[i].Name && (bool)strchr(BuiltinInfo[i].Attributes, 'z') == InStdNamespace) return strchr(BuiltinInfo[i].Attributes, 'f') != nullptr; } @@ -119,6 +119,9 @@ static bool builtinIsSupported(const Builtin::Info &BuiltinInfo, /* CPlusPlus Unsupported */ if (!LangOpts.CPlusPlus && BuiltinInfo.Langs == CXX_LANG) return false; + /* consteval Unsupported */ + if (!LangOpts.CPlusPlus20 && strchr(BuiltinInfo.Attributes, 'G') != nullptr) + return false; return true; } diff --git a/contrib/llvm-project/clang/lib/Basic/CharInfo.cpp b/contrib/llvm-project/clang/lib/Basic/CharInfo.cpp index d02054c9718f..26d693b8e9b9 100644 --- a/contrib/llvm-project/clang/lib/Basic/CharInfo.cpp +++ b/contrib/llvm-project/clang/lib/Basic/CharInfo.cpp @@ -31,20 +31,20 @@ const uint16_t clang::charinfo::InfoTable[256] = { 0 , 0 , 0 , 0 , //32 SP 33 ! 34 " 35 # //36 $ 37 % 38 & 39 ' - CHAR_SPACE , CHAR_RAWDEL , CHAR_RAWDEL , CHAR_RAWDEL , - CHAR_PUNCT , CHAR_RAWDEL , CHAR_RAWDEL , CHAR_RAWDEL , + CHAR_SPACE , CHAR_PUNCT , CHAR_PUNCT , CHAR_PUNCT , + CHAR_PUNCT , CHAR_PUNCT , CHAR_PUNCT , CHAR_PUNCT , //40 ( 41 ) 42 * 43 + //44 , 45 - 46 . 47 / - CHAR_PUNCT , CHAR_PUNCT , CHAR_RAWDEL , CHAR_RAWDEL , - CHAR_RAWDEL , CHAR_RAWDEL , CHAR_PERIOD , CHAR_RAWDEL , + CHAR_PUNCT , CHAR_PUNCT , CHAR_PUNCT , CHAR_PUNCT , + CHAR_PUNCT , CHAR_PUNCT , CHAR_PERIOD , CHAR_PUNCT , //48 0 49 1 50 2 51 3 //52 4 53 5 54 6 55 7 CHAR_DIGIT , CHAR_DIGIT , CHAR_DIGIT , CHAR_DIGIT , CHAR_DIGIT , CHAR_DIGIT , CHAR_DIGIT , CHAR_DIGIT , //56 8 57 9 58 : 59 ; //60 < 61 = 62 > 63 ? - CHAR_DIGIT , CHAR_DIGIT , CHAR_RAWDEL , CHAR_RAWDEL , - CHAR_RAWDEL , CHAR_RAWDEL , CHAR_RAWDEL , CHAR_RAWDEL , + CHAR_DIGIT , CHAR_DIGIT , CHAR_PUNCT , CHAR_PUNCT , + CHAR_PUNCT , CHAR_PUNCT , CHAR_PUNCT , CHAR_PUNCT , //64 @ 65 A 66 B 67 C //68 D 69 E 70 F 71 G CHAR_PUNCT , CHAR_XUPPER , CHAR_XUPPER , CHAR_XUPPER , @@ -59,8 +59,8 @@ const uint16_t clang::charinfo::InfoTable[256] = { CHAR_UPPER , CHAR_UPPER , CHAR_UPPER , CHAR_UPPER , //88 X 89 Y 90 Z 91 [ //92 \ 93 ] 94 ^ 95 _ - CHAR_UPPER , CHAR_UPPER , CHAR_UPPER , CHAR_RAWDEL , - CHAR_PUNCT , CHAR_RAWDEL , CHAR_RAWDEL , CHAR_UNDER , + CHAR_UPPER , CHAR_UPPER , CHAR_UPPER , CHAR_PUNCT , + CHAR_PUNCT , CHAR_PUNCT , CHAR_PUNCT , CHAR_UNDER , //96 ` 97 a 98 b 99 c //100 d 101 e 102 f 103 g CHAR_PUNCT , CHAR_XLOWER , CHAR_XLOWER , CHAR_XLOWER , @@ -75,6 +75,6 @@ const uint16_t clang::charinfo::InfoTable[256] = { CHAR_LOWER , CHAR_LOWER , CHAR_LOWER , CHAR_LOWER , //120 x 121 y 122 z 123 { //124 | 125 } 126 ~ 127 DEL - CHAR_LOWER , CHAR_LOWER , CHAR_LOWER , CHAR_RAWDEL , - CHAR_RAWDEL , CHAR_RAWDEL , CHAR_RAWDEL , 0 + CHAR_LOWER , CHAR_LOWER , CHAR_LOWER , CHAR_PUNCT , + CHAR_PUNCT , CHAR_PUNCT , CHAR_PUNCT , 0 }; diff --git a/contrib/llvm-project/clang/lib/Basic/Cuda.cpp b/contrib/llvm-project/clang/lib/Basic/Cuda.cpp index 1b1da6a1356f..faf3878f064d 100644 --- a/contrib/llvm-project/clang/lib/Basic/Cuda.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Cuda.cpp @@ -14,7 +14,7 @@ struct CudaVersionMapEntry { }; #define CUDA_ENTRY(major, minor) \ { \ -#major "." #minor, CudaVersion::CUDA_##major##minor, \ + #major "." #minor, CudaVersion::CUDA_##major##minor, \ llvm::VersionTuple(major, minor) \ } @@ -41,6 +41,8 @@ static const CudaVersionMapEntry CudaNameVersionMap[] = { CUDA_ENTRY(12, 1), CUDA_ENTRY(12, 2), CUDA_ENTRY(12, 3), + CUDA_ENTRY(12, 4), + CUDA_ENTRY(12, 5), {"", CudaVersion::NEW, llvm::VersionTuple(std::numeric_limits<int>::max())}, {"unknown", CudaVersion::UNKNOWN, {}} // End of list tombstone. }; @@ -70,23 +72,21 @@ CudaVersion ToCudaVersion(llvm::VersionTuple Version) { } namespace { -struct CudaArchToStringMap { - CudaArch arch; +struct OffloadArchToStringMap { + OffloadArch arch; const char *arch_name; const char *virtual_arch_name; }; } // namespace -#define SM2(sm, ca) \ - { CudaArch::SM_##sm, "sm_" #sm, ca } +#define SM2(sm, ca) {OffloadArch::SM_##sm, "sm_" #sm, ca} #define SM(sm) SM2(sm, "compute_" #sm) -#define GFX(gpu) \ - { CudaArch::GFX##gpu, "gfx" #gpu, "compute_amdgcn" } -static const CudaArchToStringMap arch_names[] = { +#define GFX(gpu) {OffloadArch::GFX##gpu, "gfx" #gpu, "compute_amdgcn"} +static const OffloadArchToStringMap arch_names[] = { // clang-format off - {CudaArch::UNUSED, "", ""}, + {OffloadArch::UNUSED, "", ""}, SM2(20, "compute_20"), SM2(21, "compute_20"), // Fermi - SM(30), SM(32), SM(35), SM(37), // Kepler + SM(30), {OffloadArch::SM_32_, "sm_32", "compute_32"}, SM(35), SM(37), // Kepler SM(50), SM(52), SM(53), // Maxwell SM(60), SM(61), SM(62), // Pascal SM(70), SM(72), // Volta @@ -110,6 +110,7 @@ static const CudaArchToStringMap arch_names[] = { GFX(803), // gfx803 GFX(805), // gfx805 GFX(810), // gfx810 + {OffloadArch::GFX9_GENERIC, "gfx9-generic", "compute_amdgcn"}, GFX(900), // gfx900 GFX(902), // gfx902 GFX(904), // gfx903 @@ -121,10 +122,12 @@ static const CudaArchToStringMap arch_names[] = { GFX(940), // gfx940 GFX(941), // gfx941 GFX(942), // gfx942 + {OffloadArch::GFX10_1_GENERIC, "gfx10-1-generic", "compute_amdgcn"}, GFX(1010), // gfx1010 GFX(1011), // gfx1011 GFX(1012), // gfx1012 GFX(1013), // gfx1013 + {OffloadArch::GFX10_3_GENERIC, "gfx10-3-generic", "compute_amdgcn"}, GFX(1030), // gfx1030 GFX(1031), // gfx1031 GFX(1032), // gfx1032 @@ -132,116 +135,120 @@ static const CudaArchToStringMap arch_names[] = { GFX(1034), // gfx1034 GFX(1035), // gfx1035 GFX(1036), // gfx1036 + {OffloadArch::GFX11_GENERIC, "gfx11-generic", "compute_amdgcn"}, GFX(1100), // gfx1100 GFX(1101), // gfx1101 GFX(1102), // gfx1102 GFX(1103), // gfx1103 GFX(1150), // gfx1150 GFX(1151), // gfx1151 + GFX(1152), // gfx1152 + {OffloadArch::GFX12_GENERIC, "gfx12-generic", "compute_amdgcn"}, GFX(1200), // gfx1200 GFX(1201), // gfx1201 - {CudaArch::Generic, "generic", ""}, + {OffloadArch::AMDGCNSPIRV, "amdgcnspirv", "compute_amdgcn"}, + {OffloadArch::Generic, "generic", ""}, // clang-format on }; #undef SM #undef SM2 #undef GFX -const char *CudaArchToString(CudaArch A) { +const char *OffloadArchToString(OffloadArch A) { auto result = std::find_if( std::begin(arch_names), std::end(arch_names), - [A](const CudaArchToStringMap &map) { return A == map.arch; }); + [A](const OffloadArchToStringMap &map) { return A == map.arch; }); if (result == std::end(arch_names)) return "unknown"; return result->arch_name; } -const char *CudaArchToVirtualArchString(CudaArch A) { +const char *OffloadArchToVirtualArchString(OffloadArch A) { auto result = std::find_if( std::begin(arch_names), std::end(arch_names), - [A](const CudaArchToStringMap &map) { return A == map.arch; }); + [A](const OffloadArchToStringMap &map) { return A == map.arch; }); if (result == std::end(arch_names)) return "unknown"; return result->virtual_arch_name; } -CudaArch StringToCudaArch(llvm::StringRef S) { +OffloadArch StringToOffloadArch(llvm::StringRef S) { auto result = std::find_if( std::begin(arch_names), std::end(arch_names), - [S](const CudaArchToStringMap &map) { return S == map.arch_name; }); + [S](const OffloadArchToStringMap &map) { return S == map.arch_name; }); if (result == std::end(arch_names)) - return CudaArch::UNKNOWN; + return OffloadArch::UNKNOWN; return result->arch; } -CudaVersion MinVersionForCudaArch(CudaArch A) { - if (A == CudaArch::UNKNOWN) +CudaVersion MinVersionForOffloadArch(OffloadArch A) { + if (A == OffloadArch::UNKNOWN) return CudaVersion::UNKNOWN; // AMD GPUs do not depend on CUDA versions. - if (IsAMDGpuArch(A)) + if (IsAMDOffloadArch(A)) return CudaVersion::CUDA_70; switch (A) { - case CudaArch::SM_20: - case CudaArch::SM_21: - case CudaArch::SM_30: - case CudaArch::SM_32: - case CudaArch::SM_35: - case CudaArch::SM_37: - case CudaArch::SM_50: - case CudaArch::SM_52: - case CudaArch::SM_53: + case OffloadArch::SM_20: + case OffloadArch::SM_21: + case OffloadArch::SM_30: + case OffloadArch::SM_32_: + case OffloadArch::SM_35: + case OffloadArch::SM_37: + case OffloadArch::SM_50: + case OffloadArch::SM_52: + case OffloadArch::SM_53: return CudaVersion::CUDA_70; - case CudaArch::SM_60: - case CudaArch::SM_61: - case CudaArch::SM_62: + case OffloadArch::SM_60: + case OffloadArch::SM_61: + case OffloadArch::SM_62: return CudaVersion::CUDA_80; - case CudaArch::SM_70: + case OffloadArch::SM_70: return CudaVersion::CUDA_90; - case CudaArch::SM_72: + case OffloadArch::SM_72: return CudaVersion::CUDA_91; - case CudaArch::SM_75: + case OffloadArch::SM_75: return CudaVersion::CUDA_100; - case CudaArch::SM_80: + case OffloadArch::SM_80: return CudaVersion::CUDA_110; - case CudaArch::SM_86: + case OffloadArch::SM_86: return CudaVersion::CUDA_111; - case CudaArch::SM_87: + case OffloadArch::SM_87: return CudaVersion::CUDA_114; - case CudaArch::SM_89: - case CudaArch::SM_90: + case OffloadArch::SM_89: + case OffloadArch::SM_90: return CudaVersion::CUDA_118; - case CudaArch::SM_90a: + case OffloadArch::SM_90a: return CudaVersion::CUDA_120; default: llvm_unreachable("invalid enum"); } } -CudaVersion MaxVersionForCudaArch(CudaArch A) { +CudaVersion MaxVersionForOffloadArch(OffloadArch A) { // AMD GPUs do not depend on CUDA versions. - if (IsAMDGpuArch(A)) + if (IsAMDOffloadArch(A)) return CudaVersion::NEW; switch (A) { - case CudaArch::UNKNOWN: + case OffloadArch::UNKNOWN: return CudaVersion::UNKNOWN; - case CudaArch::SM_20: - case CudaArch::SM_21: + case OffloadArch::SM_20: + case OffloadArch::SM_21: return CudaVersion::CUDA_80; - case CudaArch::SM_30: - case CudaArch::SM_32: + case OffloadArch::SM_30: + case OffloadArch::SM_32_: return CudaVersion::CUDA_102; - case CudaArch::SM_35: - case CudaArch::SM_37: + case OffloadArch::SM_35: + case OffloadArch::SM_37: return CudaVersion::CUDA_118; default: return CudaVersion::NEW; } } -bool CudaFeatureEnabled(llvm::VersionTuple Version, CudaFeature Feature) { +bool CudaFeatureEnabled(llvm::VersionTuple Version, CudaFeature Feature) { return CudaFeatureEnabled(ToCudaVersion(Version), Feature); } diff --git a/contrib/llvm-project/clang/lib/Basic/Diagnostic.cpp b/contrib/llvm-project/clang/lib/Basic/Diagnostic.cpp index 0208ccc31bd7..66776daa5e14 100644 --- a/contrib/llvm-project/clang/lib/Basic/Diagnostic.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Diagnostic.cpp @@ -360,9 +360,10 @@ void DiagnosticsEngine::setSeverity(diag::kind Diag, diag::Severity Map, "Cannot map errors into warnings!"); assert((L.isInvalid() || SourceMgr) && "No SourceMgr for valid location"); - // Don't allow a mapping to a warning override an error/fatal mapping. + // A command line -Wfoo has an invalid L and cannot override error/fatal + // mapping, while a warning pragma can. bool WasUpgradedFromWarning = false; - if (Map == diag::Severity::Warning) { + if (Map == diag::Severity::Warning && L.isInvalid()) { DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag); if (Info.getSeverity() == diag::Severity::Error || Info.getSeverity() == diag::Severity::Fatal) { @@ -851,8 +852,7 @@ FormatDiagnostic(const char *DiagStr, const char *DiagEnd, // When the diagnostic string is only "%0", the entire string is being given // by an outside source. Remove unprintable characters from this string // and skip all the other string processing. - if (DiagEnd - DiagStr == 2 && - StringRef(DiagStr, DiagEnd - DiagStr).equals("%0") && + if (DiagEnd - DiagStr == 2 && StringRef(DiagStr, DiagEnd - DiagStr) == "%0" && getArgKind(0) == DiagnosticsEngine::ak_std_string) { const std::string &S = getArgStdStr(0); EscapeStringForDiagnostic(S, OutStr); diff --git a/contrib/llvm-project/clang/lib/Basic/DiagnosticIDs.cpp b/contrib/llvm-project/clang/lib/Basic/DiagnosticIDs.cpp index 6c7bd50eefb7..cd42573968b2 100644 --- a/contrib/llvm-project/clang/lib/Basic/DiagnosticIDs.cpp +++ b/contrib/llvm-project/clang/lib/Basic/DiagnosticIDs.cpp @@ -49,6 +49,7 @@ struct StaticDiagInfoDescriptionStringTable { #include "clang/Basic/DiagnosticSemaKinds.inc" #include "clang/Basic/DiagnosticAnalysisKinds.inc" #include "clang/Basic/DiagnosticRefactoringKinds.inc" +#include "clang/Basic/DiagnosticInstallAPIKinds.inc" // clang-format on #undef DIAG }; @@ -70,7 +71,8 @@ const StaticDiagInfoDescriptionStringTable StaticDiagInfoDescriptions = { #include "clang/Basic/DiagnosticSemaKinds.inc" #include "clang/Basic/DiagnosticAnalysisKinds.inc" #include "clang/Basic/DiagnosticRefactoringKinds.inc" - // clang-format on +#include "clang/Basic/DiagnosticInstallAPIKinds.inc" +// clang-format on #undef DIAG }; @@ -95,12 +97,13 @@ const uint32_t StaticDiagInfoDescriptionOffsets[] = { #include "clang/Basic/DiagnosticSemaKinds.inc" #include "clang/Basic/DiagnosticAnalysisKinds.inc" #include "clang/Basic/DiagnosticRefactoringKinds.inc" - // clang-format on +#include "clang/Basic/DiagnosticInstallAPIKinds.inc" +// clang-format on #undef DIAG }; // Diagnostic classes. -enum { +enum DiagnosticClass { CLASS_NOTE = 0x01, CLASS_REMARK = 0x02, CLASS_WARNING = 0x03, @@ -110,15 +113,22 @@ enum { struct StaticDiagInfoRec { uint16_t DiagID; + LLVM_PREFERRED_TYPE(diag::Severity) uint8_t DefaultSeverity : 3; + LLVM_PREFERRED_TYPE(DiagnosticClass) uint8_t Class : 3; + LLVM_PREFERRED_TYPE(DiagnosticIDs::SFINAEResponse) uint8_t SFINAE : 2; uint8_t Category : 6; + LLVM_PREFERRED_TYPE(bool) uint8_t WarnNoWerror : 1; + LLVM_PREFERRED_TYPE(bool) uint8_t WarnShowInSystemHeader : 1; + LLVM_PREFERRED_TYPE(bool) uint8_t WarnShowInSystemMacro : 1; uint16_t OptionGroupIndex : 15; + LLVM_PREFERRED_TYPE(bool) uint16_t Deferrable : 1; uint16_t DescriptionLen; @@ -166,6 +176,7 @@ VALIDATE_DIAG_SIZE(CROSSTU) VALIDATE_DIAG_SIZE(SEMA) VALIDATE_DIAG_SIZE(ANALYSIS) VALIDATE_DIAG_SIZE(REFACTORING) +VALIDATE_DIAG_SIZE(INSTALLAPI) #undef VALIDATE_DIAG_SIZE #undef STRINGIFY_NAME @@ -197,6 +208,7 @@ const StaticDiagInfoRec StaticDiagInfo[] = { #include "clang/Basic/DiagnosticSemaKinds.inc" #include "clang/Basic/DiagnosticAnalysisKinds.inc" #include "clang/Basic/DiagnosticRefactoringKinds.inc" +#include "clang/Basic/DiagnosticInstallAPIKinds.inc" // clang-format on #undef DIAG }; @@ -239,6 +251,7 @@ CATEGORY(CROSSTU, COMMENT) CATEGORY(SEMA, CROSSTU) CATEGORY(ANALYSIS, SEMA) CATEGORY(REFACTORING, ANALYSIS) +CATEGORY(INSTALLAPI, REFACTORING) #undef CATEGORY // Avoid out of bounds reads. @@ -848,6 +861,9 @@ bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const { if (isARCDiagnostic(DiagID)) return false; + if (isCodegenABICheckDiagnostic(DiagID)) + return false; + return true; } @@ -855,3 +871,8 @@ bool DiagnosticIDs::isARCDiagnostic(unsigned DiagID) { unsigned cat = getCategoryNumberForDiag(DiagID); return DiagnosticIDs::getCategoryNameFromID(cat).starts_with("ARC "); } + +bool DiagnosticIDs::isCodegenABICheckDiagnostic(unsigned DiagID) { + unsigned cat = getCategoryNumberForDiag(DiagID); + return DiagnosticIDs::getCategoryNameFromID(cat) == "Codegen ABI Check"; +} diff --git a/contrib/llvm-project/clang/lib/Basic/FileManager.cpp b/contrib/llvm-project/clang/lib/Basic/FileManager.cpp index 974c8c22598f..4509cee1ca0f 100644 --- a/contrib/llvm-project/clang/lib/Basic/FileManager.cpp +++ b/contrib/llvm-project/clang/lib/Basic/FileManager.cpp @@ -39,12 +39,6 @@ using namespace clang; #define DEBUG_TYPE "file-search" -ALWAYS_ENABLED_STATISTIC(NumDirLookups, "Number of directory lookups."); -ALWAYS_ENABLED_STATISTIC(NumFileLookups, "Number of file lookups."); -ALWAYS_ENABLED_STATISTIC(NumDirCacheMisses, - "Number of directory cache misses."); -ALWAYS_ENABLED_STATISTIC(NumFileCacheMisses, "Number of file cache misses."); - //===----------------------------------------------------------------------===// // Common logic. //===----------------------------------------------------------------------===// @@ -88,6 +82,22 @@ getDirectoryFromFile(FileManager &FileMgr, StringRef Filename, return FileMgr.getDirectoryRef(DirName, CacheFailure); } +DirectoryEntry *&FileManager::getRealDirEntry(const llvm::vfs::Status &Status) { + assert(Status.isDirectory() && "The directory should exist!"); + // See if we have already opened a directory with the + // same inode (this occurs on Unix-like systems when one dir is + // symlinked to another, for example) or the same path (on + // Windows). + DirectoryEntry *&UDE = UniqueRealDirs[Status.getUniqueID()]; + + if (!UDE) { + // We don't have this directory yet, add it. We use the string + // key from the SeenDirEntries map as the string. + UDE = new (DirsAlloc.Allocate()) DirectoryEntry(); + } + return UDE; +} + /// Add all ancestors of the given path (pointing to either a file or /// a directory) as virtual directories. void FileManager::addAncestorsAsVirtualDirs(StringRef Path) { @@ -105,11 +115,21 @@ void FileManager::addAncestorsAsVirtualDirs(StringRef Path) { if (NamedDirEnt.second) return; - // Add the virtual directory to the cache. - auto *UDE = new (DirsAlloc.Allocate()) DirectoryEntry(); - UDE->Name = NamedDirEnt.first(); - NamedDirEnt.second = *UDE; - VirtualDirectoryEntries.push_back(UDE); + // Check to see if the directory exists. + llvm::vfs::Status Status; + auto statError = + getStatValue(DirName, Status, false, nullptr /*directory lookup*/); + if (statError) { + // There's no real directory at the given path. + // Add the virtual directory to the cache. + auto *UDE = new (DirsAlloc.Allocate()) DirectoryEntry(); + NamedDirEnt.second = *UDE; + VirtualDirectoryEntries.push_back(UDE); + } else { + // There is the real directory + DirectoryEntry *&UDE = getRealDirEntry(Status); + NamedDirEnt.second = *UDE; + } // Recursively add the other ancestors. addAncestorsAsVirtualDirs(DirName); @@ -169,18 +189,8 @@ FileManager::getDirectoryRef(StringRef DirName, bool CacheFailure) { return llvm::errorCodeToError(statError); } - // It exists. See if we have already opened a directory with the - // same inode (this occurs on Unix-like systems when one dir is - // symlinked to another, for example) or the same path (on - // Windows). - DirectoryEntry *&UDE = UniqueRealDirs[Status.getUniqueID()]; - - if (!UDE) { - // We don't have this directory yet, add it. We use the string - // key from the SeenDirEntries map as the string. - UDE = new (DirsAlloc.Allocate()) DirectoryEntry(); - UDE->Name = InterndDirName; - } + // It exists. + DirectoryEntry *&UDE = getRealDirEntry(Status); NamedDirEnt.second = *UDE; return DirectoryEntryRef(NamedDirEnt); @@ -324,32 +334,10 @@ FileManager::getFileRef(StringRef Filename, bool openFile, bool CacheFailure) { FileEntryRef ReturnedRef(*NamedFileEnt); if (ReusingEntry) { // Already have an entry with this inode, return it. - - // FIXME: This hack ensures that `getDir()` will use the path that was - // used to lookup this file, even if we found a file by different path - // first. This is required in order to find a module's structure when its - // headers/module map are mapped in the VFS. - // - // See above for how this will eventually be removed. `IsVFSMapped` - // *cannot* be narrowed to `ExposesExternalVFSPath` as crash reproducers - // also depend on this logic and they have `use-external-paths: false`. - if (&DirInfo.getDirEntry() != UFE->Dir && Status.IsVFSMapped) - UFE->Dir = &DirInfo.getDirEntry(); - - // Always update LastRef to the last name by which a file was accessed. - // FIXME: Neither this nor always using the first reference is correct; we - // want to switch towards a design where we return a FileName object that - // encapsulates both the name by which the file was accessed and the - // corresponding FileEntry. - // FIXME: LastRef should be removed from FileEntry once all clients adopt - // FileEntryRef. - UFE->LastRef = ReturnedRef; - return ReturnedRef; } // Otherwise, we don't have this file yet, add it. - UFE->LastRef = ReturnedRef; UFE->Size = Status.getSize(); UFE->ModTime = llvm::sys::toTimeT(Status.getLastModificationTime()); UFE->Dir = &DirInfo.getDirEntry(); @@ -387,6 +375,13 @@ llvm::Expected<FileEntryRef> FileManager::getSTDIN() { return *STDIN; } +void FileManager::trackVFSUsage(bool Active) { + FS->visit([Active](llvm::vfs::FileSystem &FileSys) { + if (auto *RFS = dyn_cast<llvm::vfs::RedirectingFileSystem>(&FileSys)) + RFS->setUsageTrackingActive(Active); + }); +} + const FileEntry *FileManager::getVirtualFile(StringRef Filename, off_t Size, time_t ModificationTime) { return &getVirtualFileRef(Filename, Size, ModificationTime).getFileEntry(); @@ -461,7 +456,6 @@ FileEntryRef FileManager::getVirtualFileRef(StringRef Filename, off_t Size, } NamedFileEnt.second = FileEntryRef::MapValue(*UFE, *DirInfo); - UFE->LastRef = FileEntryRef(NamedFileEnt); UFE->Size = Size; UFE->ModTime = ModificationTime; UFE->Dir = &DirInfo->getDirEntry(); @@ -490,7 +484,6 @@ OptionalFileEntryRef FileManager::getBypassFile(FileEntryRef VF) { FileEntry *BFE = new (FilesAlloc.Allocate()) FileEntry(); BypassFileEntries.push_back(BFE); Insertion.first->second = FileEntryRef::MapValue(*BFE, VF.getDir()); - BFE->LastRef = FileEntryRef(*Insertion.first); BFE->Size = Status.getSize(); BFE->Dir = VF.getFileEntry().Dir; BFE->ModTime = llvm::sys::toTimeT(Status.getLastModificationTime()); @@ -537,13 +530,18 @@ void FileManager::fillRealPathName(FileEntry *UFE, llvm::StringRef FileName) { llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> FileManager::getBufferForFile(FileEntryRef FE, bool isVolatile, - bool RequiresNullTerminator) { + bool RequiresNullTerminator, + std::optional<int64_t> MaybeLimit) { const FileEntry *Entry = &FE.getFileEntry(); // If the content is living on the file entry, return a reference to it. if (Entry->Content) return llvm::MemoryBuffer::getMemBuffer(Entry->Content->getMemBufferRef()); uint64_t FileSize = Entry->getSize(); + + if (MaybeLimit) + FileSize = *MaybeLimit; + // If there's a high enough chance that the file have changed since we // got its size, force a stat before opening it. if (isVolatile || Entry->isNamedPipe()) @@ -566,7 +564,7 @@ FileManager::getBufferForFile(FileEntryRef FE, bool isVolatile, llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> FileManager::getBufferForFileImpl(StringRef Filename, int64_t FileSize, bool isVolatile, - bool RequiresNullTerminator) { + bool RequiresNullTerminator) const { if (FileSystemOpts.WorkingDir.empty()) return FS->getBufferForFile(Filename, FileSize, RequiresNullTerminator, isVolatile); @@ -675,6 +673,14 @@ StringRef FileManager::getCanonicalName(const void *Entry, StringRef Name) { return CanonicalName; } +void FileManager::AddStats(const FileManager &Other) { + assert(&Other != this && "Collecting stats into the same FileManager"); + NumDirLookups += Other.NumDirLookups; + NumFileLookups += Other.NumFileLookups; + NumDirCacheMisses += Other.NumDirCacheMisses; + NumFileCacheMisses += Other.NumFileCacheMisses; +} + void FileManager::PrintStats() const { llvm::errs() << "\n*** File Manager Stats:\n"; llvm::errs() << UniqueRealFiles.size() << " real files found, " diff --git a/contrib/llvm-project/clang/lib/Basic/IdentifierTable.cpp b/contrib/llvm-project/clang/lib/Basic/IdentifierTable.cpp index d0d8316385b4..4f7ccaf4021d 100644 --- a/contrib/llvm-project/clang/lib/Basic/IdentifierTable.cpp +++ b/contrib/llvm-project/clang/lib/Basic/IdentifierTable.cpp @@ -36,7 +36,7 @@ using namespace clang; // A check to make sure the ObjCOrBuiltinID has sufficient room to store the // largest possible target/aux-target combination. If we exceed this, we likely // need to just change the ObjCOrBuiltinIDBits value in IdentifierTable.h. -static_assert(2 * LargestBuiltinID < (2 << (ObjCOrBuiltinIDBits - 1)), +static_assert(2 * LargestBuiltinID < (2 << (InterestingIdentifierBits - 1)), "Insufficient ObjCOrBuiltinID Bits"); //===----------------------------------------------------------------------===// @@ -280,13 +280,13 @@ static void AddObjCKeyword(StringRef Name, Table.get(Name).setObjCKeywordID(ObjCID); } -static void AddInterestingIdentifier(StringRef Name, - tok::InterestingIdentifierKind BTID, - IdentifierTable &Table) { - // Don't add 'not_interesting' identifier. - if (BTID != tok::not_interesting) { +static void AddNotableIdentifier(StringRef Name, + tok::NotableIdentifierKind BTID, + IdentifierTable &Table) { + // Don't add 'not_notable' identifier. + if (BTID != tok::not_notable) { IdentifierInfo &Info = Table.get(Name, tok::identifier); - Info.setInterestingIdentifierID(BTID); + Info.setNotableIdentifierID(BTID); } } @@ -306,8 +306,8 @@ void IdentifierTable::AddKeywords(const LangOptions &LangOpts) { #define OBJC_AT_KEYWORD(NAME) \ if (LangOpts.ObjC) \ AddObjCKeyword(StringRef(#NAME), tok::objc_##NAME, *this); -#define INTERESTING_IDENTIFIER(NAME) \ - AddInterestingIdentifier(StringRef(#NAME), tok::NAME, *this); +#define NOTABLE_IDENTIFIER(NAME) \ + AddNotableIdentifier(StringRef(#NAME), tok::NAME, *this); #define TESTING_KEYWORD(NAME, FLAGS) #include "clang/Basic/TokenKinds.def" @@ -425,8 +425,8 @@ tok::PPKeywordKind IdentifierInfo::getPPKeywordID() const { // collisions (if there were, the switch below would complain about duplicate // case values). Note that this depends on 'if' being null terminated. -#define HASH(LEN, FIRST, THIRD) \ - (LEN << 5) + (((FIRST-'a') + (THIRD-'a')) & 31) +#define HASH(LEN, FIRST, THIRD) \ + (LEN << 6) + (((FIRST - 'a') - (THIRD - 'a')) & 63) #define CASE(LEN, FIRST, THIRD, NAME) \ case HASH(LEN, FIRST, THIRD): \ return memcmp(Name, #NAME, LEN) ? tok::pp_not_keyword : tok::pp_ ## NAME @@ -441,6 +441,7 @@ tok::PPKeywordKind IdentifierInfo::getPPKeywordID() const { CASE( 4, 'e', 's', else); CASE( 4, 'l', 'n', line); CASE( 4, 's', 'c', sccs); + CASE( 5, 'e', 'b', embed); CASE( 5, 'e', 'd', endif); CASE( 5, 'e', 'r', error); CASE( 5, 'i', 'e', ident); @@ -541,7 +542,8 @@ unsigned Selector::getNumArgs() const { return SI->getNumArgs(); } -IdentifierInfo *Selector::getIdentifierInfoForSlot(unsigned argIndex) const { +const IdentifierInfo * +Selector::getIdentifierInfoForSlot(unsigned argIndex) const { if (getIdentifierInfoFlag() < MultiArg) { assert(argIndex == 0 && "illegal keyword index"); return getAsIdentifierInfo(); @@ -553,7 +555,7 @@ IdentifierInfo *Selector::getIdentifierInfoForSlot(unsigned argIndex) const { } StringRef Selector::getNameForSlot(unsigned int argIndex) const { - IdentifierInfo *II = getIdentifierInfoForSlot(argIndex); + const IdentifierInfo *II = getIdentifierInfoForSlot(argIndex); return II ? II->getName() : StringRef(); } @@ -574,7 +576,7 @@ std::string Selector::getAsString() const { return "<null selector>"; if (getIdentifierInfoFlag() < MultiArg) { - IdentifierInfo *II = getAsIdentifierInfo(); + const IdentifierInfo *II = getAsIdentifierInfo(); if (getNumArgs() == 0) { assert(II && "If the number of arguments is 0 then II is guaranteed to " @@ -608,7 +610,7 @@ static bool startsWithWord(StringRef name, StringRef word) { } ObjCMethodFamily Selector::getMethodFamilyImpl(Selector sel) { - IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); + const IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); if (!first) return OMF_None; StringRef name = first->getName(); @@ -655,7 +657,7 @@ ObjCMethodFamily Selector::getMethodFamilyImpl(Selector sel) { } ObjCInstanceTypeFamily Selector::getInstTypeMethodFamily(Selector sel) { - IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); + const IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); if (!first) return OIT_None; StringRef name = first->getName(); @@ -683,7 +685,7 @@ ObjCInstanceTypeFamily Selector::getInstTypeMethodFamily(Selector sel) { } ObjCStringFormatFamily Selector::getStringFormatFamilyImpl(Selector sel) { - IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); + const IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); if (!first) return SFF_None; StringRef name = first->getName(); @@ -750,7 +752,8 @@ size_t SelectorTable::getTotalMemory() const { return SelTabImpl.Allocator.getTotalMemory(); } -Selector SelectorTable::getSelector(unsigned nKeys, IdentifierInfo **IIV) { +Selector SelectorTable::getSelector(unsigned nKeys, + const IdentifierInfo **IIV) { if (nKeys < 2) return Selector(IIV[0], nKeys); diff --git a/contrib/llvm-project/clang/lib/Basic/LangOptions.cpp b/contrib/llvm-project/clang/lib/Basic/LangOptions.cpp index a0adfbf61840..e5adc034f60c 100644 --- a/contrib/llvm-project/clang/lib/Basic/LangOptions.cpp +++ b/contrib/llvm-project/clang/lib/Basic/LangOptions.cpp @@ -48,7 +48,7 @@ void LangOptions::resetNonModularOptions() { bool LangOptions::isNoBuiltinFunc(StringRef FuncName) const { for (unsigned i = 0, e = NoBuiltinFuncs.size(); i != e; ++i) - if (FuncName.equals(NoBuiltinFuncs[i])) + if (FuncName == NoBuiltinFuncs[i]) return true; return false; } @@ -112,6 +112,7 @@ void LangOptions::setLangDefaults(LangOptions &Opts, Language Lang, Opts.C11 = Std.isC11(); Opts.C17 = Std.isC17(); Opts.C23 = Std.isC23(); + Opts.C2y = Std.isC2y(); Opts.CPlusPlus = Std.isCPlusPlus(); Opts.CPlusPlus11 = Std.isCPlusPlus11(); Opts.CPlusPlus14 = Std.isCPlusPlus14(); @@ -124,6 +125,7 @@ void LangOptions::setLangDefaults(LangOptions &Opts, Language Lang, Opts.HexFloats = Std.hasHexFloats(); Opts.WChar = Std.isCPlusPlus(); Opts.Digraphs = Std.hasDigraphs(); + Opts.RawStringLiterals = Std.hasRawStringLiterals(); Opts.HLSL = Lang == Language::HLSL; if (Opts.HLSL && Opts.IncludeDefaultHeader) diff --git a/contrib/llvm-project/clang/lib/Basic/LangStandards.cpp b/contrib/llvm-project/clang/lib/Basic/LangStandards.cpp index ab09c7221dda..c8c9292abcb2 100644 --- a/contrib/llvm-project/clang/lib/Basic/LangStandards.cpp +++ b/contrib/llvm-project/clang/lib/Basic/LangStandards.cpp @@ -21,6 +21,8 @@ StringRef clang::languageToString(Language L) { return "Asm"; case Language::LLVM_IR: return "LLVM IR"; + case Language::CIR: + return "ClangIR"; case Language::C: return "C"; case Language::CXX: @@ -69,6 +71,16 @@ LangStandard::Kind LangStandard::getLangKind(StringRef Name) { .Default(lang_unspecified); } +LangStandard::Kind LangStandard::getHLSLLangKind(StringRef Name) { + return llvm::StringSwitch<LangStandard::Kind>(Name) + .Case("2016", LangStandard::lang_hlsl2016) + .Case("2017", LangStandard::lang_hlsl2017) + .Case("2018", LangStandard::lang_hlsl2018) + .Case("2021", LangStandard::lang_hlsl2021) + .Case("202x", LangStandard::lang_hlsl202x) + .Default(LangStandard::lang_unspecified); +} + const LangStandard *LangStandard::getLangStandardForName(StringRef Name) { Kind K = getLangKind(Name); if (K == lang_unspecified) @@ -82,6 +94,7 @@ LangStandard::Kind clang::getDefaultLanguageStandard(clang::Language Lang, switch (Lang) { case Language::Unknown: case Language::LLVM_IR: + case Language::CIR: llvm_unreachable("Invalid input kind!"); case Language::OpenCL: return LangStandard::lang_opencl12; diff --git a/contrib/llvm-project/clang/lib/Basic/Module.cpp b/contrib/llvm-project/clang/lib/Basic/Module.cpp index 0dac8748a98a..90b7b0d24bb6 100644 --- a/contrib/llvm-project/clang/lib/Basic/Module.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Module.cpp @@ -140,8 +140,8 @@ bool Module::isUnimportable(const LangOptions &LangOpts, return true; } for (unsigned I = 0, N = Current->Requirements.size(); I != N; ++I) { - if (hasFeature(Current->Requirements[I].first, LangOpts, Target) != - Current->Requirements[I].second) { + if (hasFeature(Current->Requirements[I].FeatureName, LangOpts, Target) != + Current->Requirements[I].RequiredState) { Req = Current->Requirements[I]; return true; } @@ -305,6 +305,10 @@ bool Module::directlyUses(const Module *Requested) { if (Requested->fullModuleNameIs({"_Builtin_stddef", "max_align_t"}) || Requested->fullModuleNameIs({"_Builtin_stddef_wint_t"})) return true; + // Darwin is allowed is to use our builtin 'ptrauth.h' and its accompanying + // module. + if (!Requested->Parent && Requested->Name == "ptrauth") + return true; if (NoUndeclaredIncludes) UndeclaredUses.insert(Requested); @@ -315,7 +319,7 @@ bool Module::directlyUses(const Module *Requested) { void Module::addRequirement(StringRef Feature, bool RequiredState, const LangOptions &LangOpts, const TargetInfo &Target) { - Requirements.push_back(Requirement(std::string(Feature), RequiredState)); + Requirements.push_back(Requirement{std::string(Feature), RequiredState}); // If this feature is currently available, we're done. if (hasFeature(Feature, LangOpts, Target) == RequiredState) @@ -375,7 +379,7 @@ Module *Module::findOrInferSubmodule(StringRef Name) { Module *Module::getGlobalModuleFragment() const { assert(isNamedModuleUnit() && "We should only query the global module " - "fragment from the C++ 20 Named modules"); + "fragment from the C++20 Named modules"); for (auto *SubModule : SubModules) if (SubModule->isExplicitGlobalModule()) @@ -386,7 +390,7 @@ Module *Module::getGlobalModuleFragment() const { Module *Module::getPrivateModuleFragment() const { assert(isNamedModuleUnit() && "We should only query the private module " - "fragment from the C++ 20 Named modules"); + "fragment from the C++20 Named modules"); for (auto *SubModule : SubModules) if (SubModule->isPrivateModule()) @@ -500,9 +504,9 @@ void Module::print(raw_ostream &OS, unsigned Indent, bool Dump) const { for (unsigned I = 0, N = Requirements.size(); I != N; ++I) { if (I) OS << ", "; - if (!Requirements[I].second) + if (!Requirements[I].RequiredState) OS << "!"; - OS << Requirements[I].first; + OS << Requirements[I].FeatureName; } OS << "\n"; } @@ -720,26 +724,3 @@ void VisibleModuleSet::setVisible(Module *M, SourceLocation Loc, }; VisitModule({M, nullptr}); } - -void VisibleModuleSet::makeTransitiveImportsVisible(Module *M, - SourceLocation Loc, - VisibleCallback Vis, - ConflictCallback Cb) { - for (auto *I : M->Imports) - setVisible(I, Loc, Vis, Cb); -} - -ASTSourceDescriptor::ASTSourceDescriptor(Module &M) - : Signature(M.Signature), ClangModule(&M) { - if (M.Directory) - Path = M.Directory->getName(); - if (auto File = M.getASTFile()) - ASTFile = File->getName(); -} - -std::string ASTSourceDescriptor::getModuleName() const { - if (ClangModule) - return ClangModule->Name; - else - return std::string(PCHModuleName); -} diff --git a/contrib/llvm-project/clang/lib/Basic/OpenMPKinds.cpp b/contrib/llvm-project/clang/lib/Basic/OpenMPKinds.cpp index 6c31b0824eb8..b141e48e77e3 100644 --- a/contrib/llvm-project/clang/lib/Basic/OpenMPKinds.cpp +++ b/contrib/llvm-project/clang/lib/Basic/OpenMPKinds.cpp @@ -574,31 +574,7 @@ const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, } bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { - return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || - DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || - DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || - DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || - DKind == OMPD_parallel_master_taskloop || - DKind == OMPD_parallel_master_taskloop_simd || - DKind == OMPD_masked_taskloop || DKind == OMPD_masked_taskloop_simd || - DKind == OMPD_parallel_masked_taskloop || DKind == OMPD_distribute || - DKind == OMPD_parallel_masked_taskloop_simd || - DKind == OMPD_target_parallel_for || - DKind == OMPD_distribute_parallel_for || - DKind == OMPD_distribute_parallel_for_simd || - DKind == OMPD_distribute_simd || - DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || - DKind == OMPD_teams_distribute || - DKind == OMPD_teams_distribute_simd || - DKind == OMPD_teams_distribute_parallel_for_simd || - DKind == OMPD_teams_distribute_parallel_for || - DKind == OMPD_target_teams_distribute || - DKind == OMPD_target_teams_distribute_parallel_for || - DKind == OMPD_target_teams_distribute_parallel_for_simd || - DKind == OMPD_target_teams_distribute_simd || DKind == OMPD_tile || - DKind == OMPD_unroll || DKind == OMPD_loop || - DKind == OMPD_teams_loop || DKind == OMPD_target_teams_loop || - DKind == OMPD_parallel_loop || DKind == OMPD_target_parallel_loop; + return getDirectiveAssociation(DKind) == Association::Loop; } bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { @@ -619,44 +595,20 @@ bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { } bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { - return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || - DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || - DKind == OMPD_parallel_master_taskloop || - DKind == OMPD_masked_taskloop || DKind == OMPD_masked_taskloop_simd || - DKind == OMPD_parallel_masked_taskloop || - DKind == OMPD_parallel_masked_taskloop_simd || - DKind == OMPD_parallel_master_taskloop_simd; + return DKind == OMPD_taskloop || + llvm::is_contained(getLeafConstructs(DKind), OMPD_taskloop); } bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { - return DKind == OMPD_parallel || DKind == OMPD_parallel_for || - DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || - DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || - DKind == OMPD_distribute_parallel_for || - DKind == OMPD_distribute_parallel_for_simd || - DKind == OMPD_target_parallel_for_simd || - DKind == OMPD_teams_distribute_parallel_for || - DKind == OMPD_teams_distribute_parallel_for_simd || - DKind == OMPD_target_teams_distribute_parallel_for || - DKind == OMPD_target_teams_distribute_parallel_for_simd || - DKind == OMPD_parallel_master || DKind == OMPD_parallel_masked || - DKind == OMPD_parallel_master_taskloop || - DKind == OMPD_parallel_master_taskloop_simd || - DKind == OMPD_parallel_masked_taskloop || - DKind == OMPD_parallel_masked_taskloop_simd || - DKind == OMPD_parallel_loop || DKind == OMPD_target_parallel_loop || - DKind == OMPD_teams_loop; + if (DKind == OMPD_teams_loop) + return true; + return DKind == OMPD_parallel || + llvm::is_contained(getLeafConstructs(DKind), OMPD_parallel); } bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { - return DKind == OMPD_target || DKind == OMPD_target_parallel || - DKind == OMPD_target_parallel_for || - DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || - DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || - DKind == OMPD_target_teams_distribute_parallel_for || - DKind == OMPD_target_teams_distribute_parallel_for_simd || - DKind == OMPD_target_teams_distribute_simd || - DKind == OMPD_target_teams_loop || DKind == OMPD_target_parallel_loop; + return DKind == OMPD_target || + llvm::is_contained(getLeafConstructs(DKind), OMPD_target); } bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { @@ -665,60 +617,45 @@ bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { } bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { - return DKind == OMPD_teams || DKind == OMPD_teams_distribute || - DKind == OMPD_teams_distribute_simd || - DKind == OMPD_teams_distribute_parallel_for_simd || - DKind == OMPD_teams_distribute_parallel_for || - DKind == OMPD_teams_loop; + if (DKind == OMPD_teams) + return true; + ArrayRef<Directive> Leaves = getLeafConstructs(DKind); + return !Leaves.empty() && Leaves.front() == OMPD_teams; } bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { - return isOpenMPNestingTeamsDirective(DKind) || DKind == OMPD_target_teams || - DKind == OMPD_target_teams_distribute || - DKind == OMPD_target_teams_distribute_parallel_for || - DKind == OMPD_target_teams_distribute_parallel_for_simd || - DKind == OMPD_target_teams_distribute_simd || - DKind == OMPD_target_teams_loop; + return DKind == OMPD_teams || + llvm::is_contained(getLeafConstructs(DKind), OMPD_teams); } bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { - return DKind == OMPD_simd || DKind == OMPD_for_simd || - DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || - DKind == OMPD_master_taskloop_simd || - DKind == OMPD_masked_taskloop_simd || - DKind == OMPD_parallel_master_taskloop_simd || - DKind == OMPD_parallel_masked_taskloop_simd || - DKind == OMPD_distribute_parallel_for_simd || - DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || - DKind == OMPD_teams_distribute_simd || - DKind == OMPD_teams_distribute_parallel_for_simd || - DKind == OMPD_target_teams_distribute_parallel_for_simd || - DKind == OMPD_target_teams_distribute_simd || - DKind == OMPD_target_parallel_for_simd; + // Avoid OMPD_declare_simd + if (getDirectiveAssociation(DKind) != Association::Loop) + return false; + // Formally, OMPD_end_do_simd also has a loop association, but + // it's a Fortran-specific directive. + + return DKind == OMPD_simd || + llvm::is_contained(getLeafConstructs(DKind), OMPD_simd); } bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { - return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || - Kind == OMPD_distribute_parallel_for_simd || - Kind == OMPD_distribute_simd; - // TODO add next directives. + if (Kind == OMPD_distribute) + return true; + ArrayRef<Directive> Leaves = getLeafConstructs(Kind); + return !Leaves.empty() && Leaves.front() == OMPD_distribute; } bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { - return isOpenMPNestingDistributeDirective(Kind) || - Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || - Kind == OMPD_teams_distribute_parallel_for_simd || - Kind == OMPD_teams_distribute_parallel_for || - Kind == OMPD_target_teams_distribute || - Kind == OMPD_target_teams_distribute_parallel_for || - Kind == OMPD_target_teams_distribute_parallel_for_simd || - Kind == OMPD_target_teams_distribute_simd; + return Kind == OMPD_distribute || + llvm::is_contained(getLeafConstructs(Kind), OMPD_distribute); } bool clang::isOpenMPGenericLoopDirective(OpenMPDirectiveKind Kind) { - return Kind == OMPD_loop || Kind == OMPD_teams_loop || - Kind == OMPD_target_teams_loop || Kind == OMPD_parallel_loop || - Kind == OMPD_target_parallel_loop; + if (Kind == OMPD_loop) + return true; + ArrayRef<Directive> Leaves = getLeafConstructs(Kind); + return !Leaves.empty() && Leaves.back() == OMPD_loop; } bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { @@ -747,7 +684,8 @@ bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { } bool clang::isOpenMPLoopTransformationDirective(OpenMPDirectiveKind DKind) { - return DKind == OMPD_tile || DKind == OMPD_unroll; + return DKind == OMPD_tile || DKind == OMPD_unroll || DKind == OMPD_reverse || + DKind == OMPD_interchange; } bool clang::isOpenMPCombinedParallelADirective(OpenMPDirectiveKind DKind) { @@ -765,139 +703,130 @@ bool clang::needsTaskBasedThreadLimit(OpenMPDirectiveKind DKind) { DKind == OMPD_target_parallel_loop; } -void clang::getOpenMPCaptureRegions( - SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, - OpenMPDirectiveKind DKind) { - assert(unsigned(DKind) < llvm::omp::Directive_enumSize); +bool clang::isOpenMPExecutableDirective(OpenMPDirectiveKind DKind) { + if (DKind == OMPD_error) + return true; + Category Cat = getDirectiveCategory(DKind); + return Cat == Category::Executable || Cat == Category::Subsidiary; +} + +bool clang::isOpenMPCapturingDirective(OpenMPDirectiveKind DKind) { + if (isOpenMPExecutableDirective(DKind)) { + switch (DKind) { + case OMPD_atomic: + case OMPD_barrier: + case OMPD_cancel: + case OMPD_cancellation_point: + case OMPD_critical: + case OMPD_depobj: + case OMPD_error: + case OMPD_flush: + case OMPD_masked: + case OMPD_master: + case OMPD_section: + case OMPD_taskwait: + case OMPD_taskyield: + return false; + default: + return !isOpenMPLoopTransformationDirective(DKind); + } + } + // Non-executable directives. switch (DKind) { case OMPD_metadirective: - CaptureRegions.push_back(OMPD_metadirective); - break; - case OMPD_parallel: - case OMPD_parallel_for: - case OMPD_parallel_for_simd: - case OMPD_parallel_master: - case OMPD_parallel_masked: - case OMPD_parallel_sections: - case OMPD_distribute_parallel_for: - case OMPD_distribute_parallel_for_simd: - case OMPD_parallel_loop: - CaptureRegions.push_back(OMPD_parallel); - break; - case OMPD_target_teams: - case OMPD_target_teams_distribute: - case OMPD_target_teams_distribute_simd: - CaptureRegions.push_back(OMPD_task); - CaptureRegions.push_back(OMPD_target); - CaptureRegions.push_back(OMPD_teams); - break; - case OMPD_teams: - case OMPD_teams_distribute: - case OMPD_teams_distribute_simd: - CaptureRegions.push_back(OMPD_teams); - break; - case OMPD_target: - case OMPD_target_simd: - CaptureRegions.push_back(OMPD_task); - CaptureRegions.push_back(OMPD_target); - break; - case OMPD_teams_loop: - case OMPD_teams_distribute_parallel_for: - case OMPD_teams_distribute_parallel_for_simd: - CaptureRegions.push_back(OMPD_teams); - CaptureRegions.push_back(OMPD_parallel); - break; - case OMPD_target_parallel: - case OMPD_target_parallel_for: - case OMPD_target_parallel_for_simd: - case OMPD_target_parallel_loop: - CaptureRegions.push_back(OMPD_task); - CaptureRegions.push_back(OMPD_target); - CaptureRegions.push_back(OMPD_parallel); - break; - case OMPD_task: - case OMPD_target_enter_data: - case OMPD_target_exit_data: - case OMPD_target_update: - CaptureRegions.push_back(OMPD_task); - break; - case OMPD_taskloop: - case OMPD_taskloop_simd: - case OMPD_master_taskloop: - case OMPD_master_taskloop_simd: - case OMPD_masked_taskloop: - case OMPD_masked_taskloop_simd: - CaptureRegions.push_back(OMPD_taskloop); - break; - case OMPD_parallel_masked_taskloop: - case OMPD_parallel_masked_taskloop_simd: - case OMPD_parallel_master_taskloop: - case OMPD_parallel_master_taskloop_simd: - CaptureRegions.push_back(OMPD_parallel); - CaptureRegions.push_back(OMPD_taskloop); - break; - case OMPD_target_teams_loop: - case OMPD_target_teams_distribute_parallel_for: - case OMPD_target_teams_distribute_parallel_for_simd: - CaptureRegions.push_back(OMPD_task); - CaptureRegions.push_back(OMPD_target); - CaptureRegions.push_back(OMPD_teams); - CaptureRegions.push_back(OMPD_parallel); - break; case OMPD_nothing: - CaptureRegions.push_back(OMPD_nothing); - break; - case OMPD_loop: - // TODO: 'loop' may require different capture regions depending on the bind - // clause or the parent directive when there is no bind clause. Use - // OMPD_unknown for now. - case OMPD_simd: - case OMPD_for: - case OMPD_for_simd: - case OMPD_sections: - case OMPD_section: - case OMPD_single: - case OMPD_master: - case OMPD_critical: - case OMPD_taskgroup: - case OMPD_distribute: - case OMPD_ordered: - case OMPD_atomic: - case OMPD_target_data: - case OMPD_distribute_simd: - case OMPD_scope: - case OMPD_dispatch: - CaptureRegions.push_back(OMPD_unknown); - break; - case OMPD_tile: - case OMPD_unroll: - // loop transformations do not introduce captures. - break; - case OMPD_threadprivate: - case OMPD_allocate: - case OMPD_taskyield: - case OMPD_barrier: - case OMPD_error: - case OMPD_taskwait: - case OMPD_cancellation_point: - case OMPD_cancel: - case OMPD_flush: - case OMPD_depobj: - case OMPD_scan: - case OMPD_declare_reduction: - case OMPD_declare_mapper: - case OMPD_declare_simd: - case OMPD_declare_target: - case OMPD_end_declare_target: - case OMPD_requires: - case OMPD_declare_variant: - case OMPD_begin_declare_variant: - case OMPD_end_declare_variant: - llvm_unreachable("OpenMP Directive is not allowed"); - case OMPD_unknown: + return true; default: - llvm_unreachable("Unknown OpenMP directive"); + break; } + return false; +} + +void clang::getOpenMPCaptureRegions( + SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, + OpenMPDirectiveKind DKind) { + assert(unsigned(DKind) < llvm::omp::Directive_enumSize); + assert(isOpenMPCapturingDirective(DKind) && "Expecting capturing directive"); + + auto GetRegionsForLeaf = [&](OpenMPDirectiveKind LKind) { + assert(isLeafConstruct(LKind) && "Epecting leaf directive"); + // Whether a leaf would require OMPD_unknown if it occured on its own. + switch (LKind) { + case OMPD_metadirective: + CaptureRegions.push_back(OMPD_metadirective); + break; + case OMPD_nothing: + CaptureRegions.push_back(OMPD_nothing); + break; + case OMPD_parallel: + CaptureRegions.push_back(OMPD_parallel); + break; + case OMPD_target: + CaptureRegions.push_back(OMPD_task); + CaptureRegions.push_back(OMPD_target); + break; + case OMPD_task: + case OMPD_target_enter_data: + case OMPD_target_exit_data: + case OMPD_target_update: + CaptureRegions.push_back(OMPD_task); + break; + case OMPD_teams: + CaptureRegions.push_back(OMPD_teams); + break; + case OMPD_taskloop: + CaptureRegions.push_back(OMPD_taskloop); + break; + case OMPD_loop: + // TODO: 'loop' may require different capture regions depending on the + // bind clause or the parent directive when there is no bind clause. + // If any of the directives that push regions here are parents of 'loop', + // assume 'parallel'. Otherwise do nothing. + if (!CaptureRegions.empty() && + !llvm::is_contained(CaptureRegions, OMPD_parallel)) + CaptureRegions.push_back(OMPD_parallel); + else + return true; + break; + case OMPD_dispatch: + case OMPD_distribute: + case OMPD_for: + case OMPD_masked: + case OMPD_master: + case OMPD_ordered: + case OMPD_scope: + case OMPD_sections: + case OMPD_simd: + case OMPD_single: + case OMPD_target_data: + case OMPD_taskgroup: + // These directives (when standalone) use OMPD_unknown as the region, + // but when they're constituents of a compound directive, and other + // leafs from that directive have specific regions, then these directives + // add no additional regions. + return true; + default: + llvm::errs() << getOpenMPDirectiveName(LKind) << '\n'; + llvm_unreachable("Unexpected directive"); + } + return false; + }; + + bool MayNeedUnknownRegion = false; + for (OpenMPDirectiveKind L : getLeafConstructsOrSelf(DKind)) + MayNeedUnknownRegion |= GetRegionsForLeaf(L); + + // We need OMPD_unknown when no regions were added, and specific leaf + // constructs were present. Push a single OMPD_unknown as the capture + /// region. + if (CaptureRegions.empty() && MayNeedUnknownRegion) + CaptureRegions.push_back(OMPD_unknown); + + // OMPD_unknown is only expected as the only region. If other regions + // are present OMPD_unknown should not be present. + assert((CaptureRegions[0] == OMPD_unknown || + !llvm::is_contained(CaptureRegions, OMPD_unknown)) && + "Misplaced OMPD_unknown"); } bool clang::checkFailClauseParameter(OpenMPClauseKind FailClauseParameter) { diff --git a/contrib/llvm-project/clang/lib/Basic/Sarif.cpp b/contrib/llvm-project/clang/lib/Basic/Sarif.cpp index 1cae7b937bc6..8c144df34167 100644 --- a/contrib/llvm-project/clang/lib/Basic/Sarif.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Sarif.cpp @@ -57,8 +57,7 @@ static std::string percentEncodeURICharacter(char C) { // should be written out directly. Otherwise, percent // encode the character and write that out instead of the // reserved character. - if (llvm::isAlnum(C) || - StringRef::npos != StringRef("-._~:@!$&'()*+,;=").find(C)) + if (llvm::isAlnum(C) || StringRef("-._~:@!$&'()*+,;=").contains(C)) return std::string(&C, 1); return "%" + llvm::toHex(StringRef(&C, 1)); } diff --git a/contrib/llvm-project/clang/lib/Basic/SourceManager.cpp b/contrib/llvm-project/clang/lib/Basic/SourceManager.cpp index 37734d3b10e7..533a9fe88a21 100644 --- a/contrib/llvm-project/clang/lib/Basic/SourceManager.cpp +++ b/contrib/llvm-project/clang/lib/Basic/SourceManager.cpp @@ -20,6 +20,7 @@ #include "llvm/ADT/MapVector.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/Statistic.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/Support/Allocator.h" @@ -46,6 +47,13 @@ using namespace clang; using namespace SrcMgr; using llvm::MemoryBuffer; +#define DEBUG_TYPE "source-manager" + +// Reaching a limit of 2^31 results in a hard error. This metric allows to track +// if particular invocation of the compiler is close to it. +STATISTIC(MaxUsedSLocBytes, "Maximum number of bytes used by source locations " + "(both loaded and local)."); + //===----------------------------------------------------------------------===// // SourceManager Helper Classes //===----------------------------------------------------------------------===// @@ -276,14 +284,14 @@ void SourceManager::AddLineNote(SourceLocation Loc, unsigned LineNo, std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc); bool Invalid = false; - const SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid); + SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid); if (!Entry.isFile() || Invalid) return; - const SrcMgr::FileInfo &FileInfo = Entry.getFile(); + SrcMgr::FileInfo &FileInfo = Entry.getFile(); // Remember that this file has #line directives now if it doesn't already. - const_cast<SrcMgr::FileInfo&>(FileInfo).setHasLineDirectives(); + FileInfo.setHasLineDirectives(); (void) getLineTable(); @@ -431,6 +439,10 @@ ContentCache &SourceManager::createMemBufferContentCache( const SrcMgr::SLocEntry &SourceManager::loadSLocEntry(unsigned Index, bool *Invalid) const { + return const_cast<SourceManager *>(this)->loadSLocEntry(Index, Invalid); +} + +SrcMgr::SLocEntry &SourceManager::loadSLocEntry(unsigned Index, bool *Invalid) { assert(!SLocEntryLoaded[Index]); if (ExternalSLocEntries->ReadSLocEntry(-(static_cast<int>(Index) + 2))) { if (Invalid) @@ -462,6 +474,7 @@ SourceManager::AllocateLoadedSLocEntries(unsigned NumSLocEntries, SLocEntryLoaded.resize(LoadedSLocEntryTable.size()); SLocEntryOffsetLoaded.resize(LoadedSLocEntryTable.size()); CurrentLoadedOffset -= TotalSize; + updateSlocUsageStats(); int BaseID = -int(LoadedSLocEntryTable.size()) - 1; LoadedSLocEntryAllocBegin.push_back(FileID::get(BaseID)); return std::make_pair(BaseID, CurrentLoadedOffset); @@ -615,6 +628,7 @@ FileID SourceManager::createFileIDImpl(ContentCache &File, StringRef Filename, // We do a +1 here because we want a SourceLocation that means "the end of the // file", e.g. for the "no newline at the end of the file" diagnostic. NextLocalOffset += FileSize + 1; + updateSlocUsageStats(); // Set LastFileIDLookup to the newly created file. The next getFileID call is // almost guaranteed to be from that file. @@ -675,6 +689,7 @@ SourceManager::createExpansionLocImpl(const ExpansionInfo &Info, } // See createFileID for that +1. NextLocalOffset += Length + 1; + updateSlocUsageStats(); return SourceLocation::getMacroLoc(NextLocalOffset - (Length + 1)); } @@ -1839,6 +1854,12 @@ void SourceManager::associateFileChunkWithMacroArgExp( MacroArgsCache[EndOffs] = EndOffsMappedLoc; } +void SourceManager::updateSlocUsageStats() const { + SourceLocation::UIntTy UsedBytes = + NextLocalOffset + (MaxLoadedOffset - CurrentLoadedOffset); + MaxUsedSLocBytes.updateMax(UsedBytes); +} + /// If \arg Loc points inside a function macro argument, the returned /// location will be the macro location in which the argument was expanded. /// If a macro argument is used multiple times, the expanded location will @@ -1911,6 +1932,24 @@ SourceManager::getDecomposedIncludedLoc(FileID FID) const { return DecompLoc; } +FileID SourceManager::getUniqueLoadedASTFileID(SourceLocation Loc) const { + assert(isLoadedSourceLocation(Loc) && + "Must be a source location in a loaded PCH/Module file"); + + auto [FID, Ignore] = getDecomposedLoc(Loc); + // `LoadedSLocEntryAllocBegin` stores the sorted lowest FID of each loaded + // allocation. Later allocations have lower FileIDs. The call below is to find + // the lowest FID of a loaded allocation from any FID in the same allocation. + // The lowest FID is used to identify a loaded allocation. + const FileID *FirstFID = + llvm::lower_bound(LoadedSLocEntryAllocBegin, FID, std::greater<FileID>{}); + + assert(FirstFID && + "The failure to find the first FileID of a " + "loaded AST from a loaded source location was unexpected."); + return *FirstFID; +} + bool SourceManager::isInTheSameTranslationUnitImpl( const std::pair<FileID, unsigned> &LOffs, const std::pair<FileID, unsigned> &ROffs) const { diff --git a/contrib/llvm-project/clang/lib/Basic/TargetInfo.cpp b/contrib/llvm-project/clang/lib/Basic/TargetInfo.cpp index 96b3ad9ba2f2..29f5cd14e46e 100644 --- a/contrib/llvm-project/clang/lib/Basic/TargetInfo.cpp +++ b/contrib/llvm-project/clang/lib/Basic/TargetInfo.cpp @@ -157,6 +157,7 @@ TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) { HasAArch64SVETypes = false; HasRISCVVTypes = false; AllowAMDGPUUnsafeFPAtomics = false; + HasUnalignedAccess = false; ARMCDECoprocMask = 0; // Default to no types using fpret. @@ -405,6 +406,16 @@ void TargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) { LongDoubleAlign = 64; } + // HLSL explicitly defines the sizes and formats of some data types, and we + // need to conform to those regardless of what architecture you are targeting. + if (Opts.HLSL) { + LongWidth = LongAlign = 64; + if (!Opts.NativeHalfType) { + HalfFormat = &llvm::APFloat::IEEEsingle(); + HalfWidth = HalfAlign = 32; + } + } + if (Opts.OpenCL) { // OpenCL C requires specific widths for types, irrespective of // what these normally are for the target. @@ -925,6 +936,10 @@ bool TargetInfo::validateInputConstraint( return true; } +bool TargetInfo::validatePointerAuthKey(const llvm::APSInt &value) const { + return false; +} + void TargetInfo::CheckFixedPointBits() const { // Check that the number of fractional and integral bits (and maybe sign) can // fit into the bits given for a fixed point type. diff --git a/contrib/llvm-project/clang/lib/Basic/Targets.cpp b/contrib/llvm-project/clang/lib/Basic/Targets.cpp index e3283510c6aa..29133f9ee8fc 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets.cpp @@ -673,8 +673,11 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple, } case llvm::Triple::spirv64: { if (os != llvm::Triple::UnknownOS || - Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) + Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) { + if (os == llvm::Triple::OSType::AMDHSA) + return std::make_unique<SPIRV64AMDGCNTargetInfo>(Triple, Opts); return nullptr; + } return std::make_unique<SPIRV64TargetInfo>(Triple, Opts); } case llvm::Triple::wasm32: @@ -760,7 +763,7 @@ using namespace clang::targets; TargetInfo * TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr<TargetOptions> &Opts) { - llvm::Triple Triple(Opts->Triple); + llvm::Triple Triple(llvm::Triple::normalize(Opts->Triple)); // Construct the target std::unique_ptr<TargetInfo> Target = AllocateTarget(Triple, *Opts); diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/AArch64.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/AArch64.cpp index f5a5d689fa09..63fc15f916c5 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/AArch64.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/AArch64.cpp @@ -11,9 +11,11 @@ //===----------------------------------------------------------------------===// #include "AArch64.h" +#include "clang/Basic/Diagnostic.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/TargetBuiltins.h" #include "clang/Basic/TargetInfo.h" +#include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSwitch.h" @@ -152,6 +154,7 @@ AArch64TargetInfo::AArch64TargetInfo(const llvm::Triple &Triple, else LongWidth = LongAlign = PointerWidth = PointerAlign = 32; + BitIntMaxAlign = 128; MaxVectorAlign = 128; MaxAtomicInlineWidth = 128; MaxAtomicPromoteWidth = 128; @@ -186,6 +189,8 @@ AArch64TargetInfo::AArch64TargetInfo(const llvm::Triple &Triple, assert(UseBitFieldTypeAlignment && "bitfields affect type alignment"); UseZeroLengthBitfieldAlignment = true; + HasUnalignedAccess = true; + // AArch64 targets default to using the ARM C++ ABI. TheCXXABI.set(TargetCXXABI::GenericAArch64); @@ -199,18 +204,47 @@ AArch64TargetInfo::AArch64TargetInfo(const llvm::Triple &Triple, StringRef AArch64TargetInfo::getABI() const { return ABI; } bool AArch64TargetInfo::setABI(const std::string &Name) { - if (Name != "aapcs" && Name != "darwinpcs") + if (Name != "aapcs" && Name != "aapcs-soft" && Name != "darwinpcs" && + Name != "pauthtest") return false; ABI = Name; return true; } +bool AArch64TargetInfo::validateTarget(DiagnosticsEngine &Diags) const { + if (hasFeature("fp") && ABI == "aapcs-soft") { + // aapcs-soft is not allowed for targets with an FPU, to avoid there being + // two incomatible ABIs. + Diags.Report(diag::err_target_unsupported_abi_with_fpu) << ABI; + return false; + } + if (getTriple().getEnvironment() == llvm::Triple::PAuthTest && + getTriple().getOS() != llvm::Triple::Linux) { + Diags.Report(diag::err_target_unsupported_abi_for_triple) + << getTriple().getEnvironmentName() << getTriple().getTriple(); + return false; + } + return true; +} + +bool AArch64TargetInfo::validateGlobalRegisterVariable( + StringRef RegName, unsigned RegSize, bool &HasSizeMismatch) const { + if ((RegName == "sp") || RegName.starts_with("x")) { + HasSizeMismatch = RegSize != 64; + return true; + } else if (RegName.starts_with("w")) { + HasSizeMismatch = RegSize != 32; + return true; + } + return false; +} + bool AArch64TargetInfo::validateBranchProtection(StringRef Spec, StringRef, BranchProtectionInfo &BPI, StringRef &Err) const { llvm::ARM::ParsedBranchProtection PBP; - if (!llvm::ARM::parseBranchProtection(Spec, PBP, Err)) + if (!llvm::ARM::parseBranchProtection(Spec, PBP, Err, HasPAuthLR)) return false; BPI.SignReturnAddr = @@ -231,7 +265,7 @@ bool AArch64TargetInfo::validateBranchProtection(StringRef Spec, StringRef, } bool AArch64TargetInfo::isValidCPUName(StringRef Name) const { - return Name == "generic" || llvm::AArch64::parseCpu(Name); + return llvm::AArch64::parseCpu(Name).has_value(); } bool AArch64TargetInfo::setCPU(const std::string &Name) { @@ -271,7 +305,6 @@ void AArch64TargetInfo::getTargetDefinesARMV84A(const LangOptions &Opts, void AArch64TargetInfo::getTargetDefinesARMV85A(const LangOptions &Opts, MacroBuilder &Builder) const { Builder.defineMacro("__ARM_FEATURE_FRINT", "1"); - Builder.defineMacro("__ARM_FEATURE_BTI", "1"); // Also include the Armv8.4 defines getTargetDefinesARMV84A(Opts, Builder); } @@ -423,6 +456,9 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts, if (HasSVE2) Builder.defineMacro("__ARM_FEATURE_SVE2", "1"); + if (HasSVE2p1) + Builder.defineMacro("__ARM_FEATURE_SVE2p1", "1"); + if (HasSVE2 && HasSVE2AES) Builder.defineMacro("__ARM_FEATURE_SVE2_AES", "1"); @@ -435,16 +471,25 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts, if (HasSVE2 && HasSVE2SM4) Builder.defineMacro("__ARM_FEATURE_SVE2_SM4", "1"); + if (HasSVEB16B16) + Builder.defineMacro("__ARM_FEATURE_SVE_B16B16", "1"); + if (HasSME) { Builder.defineMacro("__ARM_FEATURE_SME"); Builder.defineMacro("__ARM_FEATURE_LOCALLY_STREAMING", "1"); } - if (HasSME2) { - Builder.defineMacro("__ARM_FEATURE_SME"); - Builder.defineMacro("__ARM_FEATURE_SME2"); - Builder.defineMacro("__ARM_FEATURE_LOCALLY_STREAMING", "1"); - } + if (HasSME2) + Builder.defineMacro("__ARM_FEATURE_SME2", "1"); + + if (HasSME2p1) + Builder.defineMacro("__ARM_FEATURE_SME2p1", "1"); + + if (HasSMEF16F16) + Builder.defineMacro("__ARM_FEATURE_SME_F16F16", "1"); + + if (HasSMEB16B16) + Builder.defineMacro("__ARM_FEATURE_SME_B16B16", "1"); if (HasCRC) Builder.defineMacro("__ARM_FEATURE_CRC32", "1"); @@ -481,7 +526,13 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts, if (HasPAuth) Builder.defineMacro("__ARM_FEATURE_PAUTH", "1"); - if (HasUnaligned) + if (HasPAuthLR) + Builder.defineMacro("__ARM_FEATURE_PAUTH_LR", "1"); + + if (HasBTI) + Builder.defineMacro("__ARM_FEATURE_BTI", "1"); + + if (HasUnalignedAccess) Builder.defineMacro("__ARM_FEATURE_UNALIGNED", "1"); if ((FPU & NeonMode) && HasFullFP16) @@ -532,6 +583,7 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts, // 0: Protection using the A key // 1: Protection using the B key // 2: Protection including leaf functions + // 3: Protection using PC as a diversifier unsigned Value = 0; if (Opts.isSignReturnAddressWithAKey()) @@ -542,6 +594,9 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts, if (Opts.isSignReturnAddressScopeAll()) Value |= (1 << 2); + if (Opts.BranchProtectionPAuthLR) + Value |= (1 << 3); + Builder.defineMacro("__ARM_FEATURE_PAC_DEFAULT", std::to_string(Value)); } @@ -637,37 +692,40 @@ AArch64TargetInfo::getVScaleRange(const LangOptions &LangOpts) const { unsigned AArch64TargetInfo::multiVersionSortPriority(StringRef Name) const { if (Name == "default") return 0; - if (auto Ext = llvm::AArch64::parseArchExtension(Name)) - return Ext->FmvPriority; + if (auto Ext = llvm::AArch64::parseFMVExtension(Name)) + return Ext->Priority; return 0; } unsigned AArch64TargetInfo::multiVersionFeatureCost() const { // Take the maximum priority as per feature cost, so more features win. - return llvm::AArch64::ExtensionInfo::MaxFMVPriority; + constexpr unsigned MaxFMVPriority = 1000; + return MaxFMVPriority; } bool AArch64TargetInfo::doesFeatureAffectCodeGen(StringRef Name) const { - if (auto Ext = llvm::AArch64::parseArchExtension(Name)) - return !Ext->DependentFeatures.empty(); + // FMV extensions which imply no backend features do not affect codegen. + if (auto Ext = llvm::AArch64::parseFMVExtension(Name)) + return !Ext->Features.empty(); return false; } -StringRef AArch64TargetInfo::getFeatureDependencies(StringRef Name) const { - if (auto Ext = llvm::AArch64::parseArchExtension(Name)) - return Ext->DependentFeatures; - return StringRef(); -} - bool AArch64TargetInfo::validateCpuSupports(StringRef FeatureStr) const { - return llvm::AArch64::parseArchExtension(FeatureStr).has_value(); + // CPU features might be separated by '+', extract them and check + llvm::SmallVector<StringRef, 8> Features; + FeatureStr.split(Features, "+"); + for (auto &Feature : Features) + if (!llvm::AArch64::parseFMVExtension(Feature.trim()).has_value()) + return false; + return true; } bool AArch64TargetInfo::hasFeature(StringRef Feature) const { return llvm::StringSwitch<bool>(Feature) .Cases("aarch64", "arm64", "arm", true) .Case("fmv", HasFMV) - .Cases("neon", "fp", "simd", FPU & NeonMode) + .Case("fp", FPU & FPUMode) + .Cases("neon", "simd", FPU & NeonMode) .Case("jscvt", HasJSCVT) .Case("fcma", HasFCMA) .Case("rng", HasRandGen) @@ -693,6 +751,7 @@ bool AArch64TargetInfo::hasFeature(StringRef Feature) const { .Case("sve", FPU & SveMode) .Case("sve-bf16", FPU & SveMode && HasBFloat16) .Case("sve-i8mm", FPU & SveMode && HasMatMul) + .Case("sve-b16b16", HasSVEB16B16) .Case("f32mm", FPU & SveMode && HasMatmulFP32) .Case("f64mm", FPU & SveMode && HasMatmulFP64) .Case("sve2", FPU & SveMode && HasSVE2) @@ -700,11 +759,15 @@ bool AArch64TargetInfo::hasFeature(StringRef Feature) const { .Case("sve2-bitperm", FPU & SveMode && HasSVE2BitPerm) .Case("sve2-sha3", FPU & SveMode && HasSVE2SHA3) .Case("sve2-sm4", FPU & SveMode && HasSVE2SM4) + .Case("sve2p1", FPU & SveMode && HasSVE2p1) .Case("sme", HasSME) .Case("sme2", HasSME2) + .Case("sme2p1", HasSME2p1) .Case("sme-f64f64", HasSMEF64F64) .Case("sme-i16i64", HasSMEI16I64) .Case("sme-fa64", HasSMEFA64) + .Case("sme-f16f16", HasSMEF16F16) + .Case("sme-b16b16", HasSMEB16B16) .Cases("memtag", "memtag2", HasMTE) .Case("sb", HasSB) .Case("predres", HasPredRes) @@ -777,6 +840,13 @@ bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, HasFullFP16 = true; HasSVE2 = true; } + if (Feature == "+sve2p1") { + FPU |= NeonMode; + FPU |= SveMode; + HasFullFP16 = true; + HasSVE2 = true; + HasSVE2p1 = true; + } if (Feature == "+sve2-aes") { FPU |= NeonMode; FPU |= SveMode; @@ -798,6 +868,8 @@ bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, HasSVE2 = true; HasSVE2SM4 = true; } + if (Feature == "+sve-b16b16") + HasSVEB16B16 = true; if (Feature == "+sve2-bitperm") { FPU |= NeonMode; FPU |= SveMode; @@ -828,6 +900,13 @@ bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, HasBFloat16 = true; HasFullFP16 = true; } + if (Feature == "+sme2p1") { + HasSME = true; + HasSME2 = true; + HasSME2p1 = true; + HasBFloat16 = true; + HasFullFP16 = true; + } if (Feature == "+sme-f64f64") { HasSME = true; HasSMEF64F64 = true; @@ -847,6 +926,21 @@ bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, HasSVE2 = true; HasSMEFA64 = true; } + if (Feature == "+sme-f16f16") { + HasSME = true; + HasSME2 = true; + HasBFloat16 = true; + HasFullFP16 = true; + HasSMEF16F16 = true; + } + if (Feature == "+sme-b16b16") { + HasSME = true; + HasSME2 = true; + HasBFloat16 = true; + HasFullFP16 = true; + HasSVEB16B16 = true; + HasSMEB16B16 = true; + } if (Feature == "+sb") HasSB = true; if (Feature == "+predres") @@ -895,7 +989,8 @@ bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, HasSM4 = true; } if (Feature == "+strict-align") - HasUnaligned = false; + HasUnalignedAccess = false; + // All predecessor archs are added but select the latest one for ArchKind. if (Feature == "+v8a" && ArchInfo->Version < llvm::AArch64::ARMV8A.Version) ArchInfo = &llvm::AArch64::ARMV8A; @@ -988,6 +1083,10 @@ bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, HasGCS = true; if (Feature == "+rcpc3") HasRCPC3 = true; + if (Feature == "+pauth-lr") { + HasPAuthLR = true; + HasPAuth = true; + } } // Check features that are manually disabled by command line options. @@ -1016,57 +1115,17 @@ bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, return true; } -bool AArch64TargetInfo::initFeatureMap( - llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU, - const std::vector<std::string> &FeaturesVec) const { - std::vector<std::string> UpdatedFeaturesVec; - // Parse the CPU and add any implied features. - std::optional<llvm::AArch64::CpuInfo> CpuInfo = llvm::AArch64::parseCpu(CPU); - if (CpuInfo) { - auto Exts = CpuInfo->getImpliedExtensions(); - std::vector<StringRef> CPUFeats; - llvm::AArch64::getExtensionFeatures(Exts, CPUFeats); - for (auto F : CPUFeats) { - assert((F[0] == '+' || F[0] == '-') && "Expected +/- in target feature!"); - UpdatedFeaturesVec.push_back(F.str()); - } - } - - // Process target and dependent features. This is done in two loops collecting - // them into UpdatedFeaturesVec: first to add dependent '+'features, second to - // add target '+/-'features that can later disable some of features added on - // the first loop. Function Multi Versioning features begin with '?'. - for (const auto &Feature : FeaturesVec) - if (((Feature[0] == '?' || Feature[0] == '+')) && - AArch64TargetInfo::doesFeatureAffectCodeGen(Feature.substr(1))) { - StringRef DepFeatures = - AArch64TargetInfo::getFeatureDependencies(Feature.substr(1)); - SmallVector<StringRef, 1> AttrFeatures; - DepFeatures.split(AttrFeatures, ","); - for (auto F : AttrFeatures) - UpdatedFeaturesVec.push_back(F.str()); - } - for (const auto &Feature : FeaturesVec) - if (Feature[0] != '?') { - std::string UpdatedFeature = Feature; - if (Feature[0] == '+') { - std::optional<llvm::AArch64::ExtensionInfo> Extension = - llvm::AArch64::parseArchExtension(Feature.substr(1)); - if (Extension) - UpdatedFeature = Extension->Feature.str(); - } - UpdatedFeaturesVec.push_back(UpdatedFeature); - } - - return TargetInfo::initFeatureMap(Features, Diags, CPU, UpdatedFeaturesVec); -} - // Parse AArch64 Target attributes, which are a comma separated list of: // "arch=<arch>" - parsed to features as per -march=.. // "cpu=<cpu>" - parsed to features as per -mcpu=.., with CPU set to <cpu> // "tune=<cpu>" - TuneCPU set to <cpu> // "feature", "no-feature" - Add (or remove) feature. // "+feature", "+nofeature" - Add (or remove) feature. +// +// A feature may correspond to an Extension (anything with a corresponding +// AEK_), in which case an ExtensionSet is used to parse it and expand its +// dependencies. If the feature does not yield a successful parse then it +// is passed through. ParsedTargetAttr AArch64TargetInfo::parseTargetAttr(StringRef Features) const { ParsedTargetAttr Ret; if (Features == "default") @@ -1076,23 +1135,31 @@ ParsedTargetAttr AArch64TargetInfo::parseTargetAttr(StringRef Features) const { bool FoundArch = false; auto SplitAndAddFeatures = [](StringRef FeatString, - std::vector<std::string> &Features) { + std::vector<std::string> &Features, + llvm::AArch64::ExtensionSet &FeatureBits) { SmallVector<StringRef, 8> SplitFeatures; FeatString.split(SplitFeatures, StringRef("+"), -1, false); for (StringRef Feature : SplitFeatures) { - StringRef FeatureName = llvm::AArch64::getArchExtFeature(Feature); - if (!FeatureName.empty()) - Features.push_back(FeatureName.str()); + if (FeatureBits.parseModifier(Feature)) + continue; + // Pass through anything that failed to parse so that we can emit + // diagnostics, as well as valid internal feature names. + // + // FIXME: We should consider rejecting internal feature names like + // neon, v8a, etc. + // FIXME: We should consider emitting diagnostics here. + if (Feature.starts_with("no")) + Features.push_back("-" + Feature.drop_front(2).str()); else - // Pushing the original feature string to give a sema error later on - // when they get checked. - if (Feature.starts_with("no")) - Features.push_back("-" + Feature.drop_front(2).str()); - else - Features.push_back("+" + Feature.str()); + Features.push_back("+" + Feature.str()); } }; + llvm::AArch64::ExtensionSet FeatureBits; + // Reconstruct the bitset from the command line option features. + FeatureBits.reconstructFromParsedFeatures(getTargetOpts().FeaturesAsWritten, + Ret.Features); + for (auto &Feature : AttrFeatures) { Feature = Feature.trim(); if (Feature.starts_with("fpmath=")) @@ -1115,9 +1182,9 @@ ParsedTargetAttr AArch64TargetInfo::parseTargetAttr(StringRef Features) const { // Ret.Features. if (!AI) continue; - Ret.Features.push_back(AI->ArchFeature.str()); + FeatureBits.addArchDefaults(*AI); // Add any extra features, after the + - SplitAndAddFeatures(Split.second, Ret.Features); + SplitAndAddFeatures(Split.second, Ret.Features, FeatureBits); } else if (Feature.starts_with("cpu=")) { if (!Ret.CPU.empty()) Ret.Duplicate = "cpu="; @@ -1127,7 +1194,10 @@ ParsedTargetAttr AArch64TargetInfo::parseTargetAttr(StringRef Features) const { std::pair<StringRef, StringRef> Split = Feature.split("=").second.trim().split("+"); Ret.CPU = Split.first; - SplitAndAddFeatures(Split.second, Ret.Features); + if (auto CpuInfo = llvm::AArch64::parseCpu(Ret.CPU)) { + FeatureBits.addCPUDefaults(*CpuInfo); + SplitAndAddFeatures(Split.second, Ret.Features, FeatureBits); + } } } else if (Feature.starts_with("tune=")) { if (!Ret.Tune.empty()) @@ -1135,25 +1205,23 @@ ParsedTargetAttr AArch64TargetInfo::parseTargetAttr(StringRef Features) const { else Ret.Tune = Feature.split("=").second.trim(); } else if (Feature.starts_with("+")) { - SplitAndAddFeatures(Feature, Ret.Features); - } else if (Feature.starts_with("no-")) { - StringRef FeatureName = - llvm::AArch64::getArchExtFeature(Feature.split("-").second); - if (!FeatureName.empty()) - Ret.Features.push_back("-" + FeatureName.drop_front(1).str()); - else - Ret.Features.push_back("-" + Feature.split("-").second.str()); + SplitAndAddFeatures(Feature, Ret.Features, FeatureBits); } else { - // Try parsing the string to the internal target feature name. If it is - // invalid, add the original string (which could already be an internal - // name). These should be checked later by isValidFeatureName. - StringRef FeatureName = llvm::AArch64::getArchExtFeature(Feature); - if (!FeatureName.empty()) - Ret.Features.push_back(FeatureName.str()); + if (FeatureBits.parseModifier(Feature, /* AllowNoDashForm = */ true)) + continue; + // Pass through anything that failed to parse so that we can emit + // diagnostics, as well as valid internal feature names. + // + // FIXME: We should consider rejecting internal feature names like + // neon, v8a, etc. + // FIXME: We should consider emitting diagnostics here. + if (Feature.starts_with("no-")) + Ret.Features.push_back("-" + Feature.drop_front(3).str()); else Ret.Features.push_back("+" + Feature.str()); } } + FeatureBits.toLLVMFeatureList(Ret.Features); return Ret; } @@ -1169,6 +1237,7 @@ AArch64TargetInfo::checkCallingConvention(CallingConv CC) const { case CC_SwiftAsync: case CC_PreserveMost: case CC_PreserveAll: + case CC_PreserveNone: case CC_OpenCLKernel: case CC_AArch64VectorCall: case CC_AArch64SVEPCS: @@ -1433,6 +1502,11 @@ int AArch64TargetInfo::getEHDataRegisterNumber(unsigned RegNo) const { return -1; } +bool AArch64TargetInfo::validatePointerAuthKey( + const llvm::APSInt &value) const { + return 0 <= value && value <= 3; +} + bool AArch64TargetInfo::hasInt128Type() const { return true; } AArch64leTargetInfo::AArch64leTargetInfo(const llvm::Triple &Triple, @@ -1442,11 +1516,11 @@ AArch64leTargetInfo::AArch64leTargetInfo(const llvm::Triple &Triple, void AArch64leTargetInfo::setDataLayout() { if (getTriple().isOSBinFormatMachO()) { if(getTriple().isArch32Bit()) - resetDataLayout("e-m:o-p:32:32-i64:64-i128:128-n32:64-S128", "_"); + resetDataLayout("e-m:o-p:32:32-i64:64-i128:128-n32:64-S128-Fn32", "_"); else - resetDataLayout("e-m:o-i64:64-i128:128-n32:64-S128", "_"); + resetDataLayout("e-m:o-i64:64-i128:128-n32:64-S128-Fn32", "_"); } else - resetDataLayout("e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"); + resetDataLayout("e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32"); } void AArch64leTargetInfo::getTargetDefines(const LangOptions &Opts, @@ -1469,7 +1543,7 @@ void AArch64beTargetInfo::getTargetDefines(const LangOptions &Opts, void AArch64beTargetInfo::setDataLayout() { assert(!getTriple().isOSBinFormatMachO()); - resetDataLayout("E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"); + resetDataLayout("E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32"); } WindowsARM64TargetInfo::WindowsARM64TargetInfo(const llvm::Triple &Triple, @@ -1492,8 +1566,8 @@ WindowsARM64TargetInfo::WindowsARM64TargetInfo(const llvm::Triple &Triple, void WindowsARM64TargetInfo::setDataLayout() { resetDataLayout(Triple.isOSBinFormatMachO() - ? "e-m:o-i64:64-i128:128-n32:64-S128" - : "e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128", + ? "e-m:o-i64:64-i128:128-n32:64-S128-Fn32" + : "e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128-Fn32", Triple.isOSBinFormatMachO() ? "_" : ""); } @@ -1505,15 +1579,19 @@ WindowsARM64TargetInfo::getBuiltinVaListKind() const { TargetInfo::CallingConvCheckResult WindowsARM64TargetInfo::checkCallingConvention(CallingConv CC) const { switch (CC) { + case CC_X86VectorCall: + if (getTriple().isWindowsArm64EC()) + return CCCR_OK; + return CCCR_Ignore; case CC_X86StdCall: case CC_X86ThisCall: case CC_X86FastCall: - case CC_X86VectorCall: return CCCR_Ignore; case CC_C: case CC_OpenCLKernel: case CC_PreserveMost: case CC_PreserveAll: + case CC_PreserveNone: case CC_Swift: case CC_SwiftAsync: case CC_Win64: @@ -1546,8 +1624,10 @@ MicrosoftARM64TargetInfo::getCallingConvKind(bool ClangABICompat4) const { return CCK_MicrosoftWin64; } -unsigned MicrosoftARM64TargetInfo::getMinGlobalAlign(uint64_t TypeSize) const { - unsigned Align = WindowsARM64TargetInfo::getMinGlobalAlign(TypeSize); +unsigned MicrosoftARM64TargetInfo::getMinGlobalAlign(uint64_t TypeSize, + bool HasNonWeakDef) const { + unsigned Align = + WindowsARM64TargetInfo::getMinGlobalAlign(TypeSize, HasNonWeakDef); // MSVC does size based alignment for arm64 based on alignment section in // below document, replicate that to keep alignment consistent with object diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/AArch64.h b/contrib/llvm-project/clang/lib/Basic/Targets/AArch64.h index 9699222b0bf7..526f7f30a386 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/AArch64.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/AArch64.h @@ -38,7 +38,6 @@ class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo { bool HasSHA2 = false; bool HasSHA3 = false; bool HasSM4 = false; - bool HasUnaligned = true; bool HasFullFP16 = false; bool HasDotProd = false; bool HasFP16FML = false; @@ -50,9 +49,11 @@ class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo { bool HasMatMul = false; bool HasBFloat16 = false; bool HasSVE2 = false; + bool HasSVE2p1 = false; bool HasSVE2AES = false; bool HasSVE2SHA3 = false; bool HasSVE2SM4 = false; + bool HasSVEB16B16 = false; bool HasSVE2BitPerm = false; bool HasMatmulFP64 = false; bool HasMatmulFP32 = false; @@ -71,6 +72,9 @@ class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo { bool HasSME2 = false; bool HasSMEF64F64 = false; bool HasSMEI16I64 = false; + bool HasSMEF16F16 = false; + bool HasSMEB16B16 = false; + bool HasSME2p1 = false; bool HasSB = false; bool HasPredRes = false; bool HasSSBS = false; @@ -85,6 +89,7 @@ class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo { bool HasGCS = false; bool HasRCPC3 = false; bool HasSMEFA64 = false; + bool HasPAuthLR = false; const llvm::AArch64::ArchInfo *ArchInfo = &llvm::AArch64::ARMV8A; @@ -107,10 +112,6 @@ public: unsigned multiVersionSortPriority(StringRef Name) const override; unsigned multiVersionFeatureCost() const override; - bool - initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, - StringRef CPU, - const std::vector<std::string> &FeaturesVec) const override; bool useFP16ConversionIntrinsics() const override { return false; } @@ -155,7 +156,6 @@ public: std::optional<std::pair<unsigned, unsigned>> getVScaleRange(const LangOptions &LangOpts) const override; bool doesFeatureAffectCodeGen(StringRef Name) const override; - StringRef getFeatureDependencies(StringRef Name) const override; bool validateCpuSupports(StringRef FeatureStr) const override; bool hasFeature(StringRef Feature) const override; void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name, @@ -164,7 +164,7 @@ public: DiagnosticsEngine &Diags) override; ParsedTargetAttr parseTargetAttr(StringRef Str) const override; bool supportsTargetAttributeTune() const override { return true; } - + bool supportsCpuSupports() const override { return true; } bool checkArithmeticFenceSupported() const override { return true; } bool hasBFloat16Type() const override; @@ -194,10 +194,17 @@ public: int getEHDataRegisterNumber(unsigned RegNo) const override; + bool validatePointerAuthKey(const llvm::APSInt &value) const override; + const char *getBFloat16Mangling() const override { return "u6__bf16"; }; bool hasInt128Type() const override; bool hasBitIntType() const override { return true; } + + bool validateTarget(DiagnosticsEngine &Diags) const override; + + bool validateGlobalRegisterVariable(StringRef RegName, unsigned RegSize, + bool &HasSizeMismatch) const override; }; class LLVM_LIBRARY_VISIBILITY AArch64leTargetInfo : public AArch64TargetInfo { @@ -237,7 +244,8 @@ public: TargetInfo::CallingConvKind getCallingConvKind(bool ClangABICompat4) const override; - unsigned getMinGlobalAlign(uint64_t TypeSize) const override; + unsigned getMinGlobalAlign(uint64_t TypeSize, + bool HasNonWeakDef) const override; }; // ARM64 MinGW target diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/AMDGPU.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/AMDGPU.cpp index 6f3a4908623d..3b748d0249d5 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/AMDGPU.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/AMDGPU.cpp @@ -17,6 +17,7 @@ #include "clang/Basic/LangOptions.h" #include "clang/Basic/MacroBuilder.h" #include "clang/Basic/TargetBuiltins.h" +#include "llvm/ADT/SmallString.h" using namespace clang; using namespace clang::targets; @@ -186,9 +187,15 @@ bool AMDGPUTargetInfo::initFeatureMap( return false; // TODO: Should move this logic into TargetParser - std::string ErrorMsg; - if (!insertWaveSizeFeature(CPU, getTriple(), Features, ErrorMsg)) { - Diags.Report(diag::err_invalid_feature_combination) << ErrorMsg; + auto HasError = insertWaveSizeFeature(CPU, getTriple(), Features); + switch (HasError.first) { + default: + break; + case llvm::AMDGPU::INVALID_FEATURE_COMBINATION: + Diags.Report(diag::err_invalid_feature_combination) << HasError.second; + return false; + case llvm::AMDGPU::UNSUPPORTED_TARGET_FEATURE: + Diags.Report(diag::err_opt_not_valid_on_target) << HasError.second; return false; } @@ -231,7 +238,7 @@ AMDGPUTargetInfo::AMDGPUTargetInfo(const llvm::Triple &Triple, HasLegalHalfType = true; HasFloat16 = true; - WavefrontSize = GPUFeatures & llvm::AMDGPU::FEATURE_WAVE32 ? 32 : 64; + WavefrontSize = (GPUFeatures & llvm::AMDGPU::FEATURE_WAVE32) ? 32 : 64; AllowAMDGPUUnsafeFPAtomics = Opts.AllowAMDGPUUnsafeFPAtomics; // Set pointer width and alignment for the generic address space. @@ -274,30 +281,42 @@ void AMDGPUTargetInfo::getTargetDefines(const LangOptions &Opts, else Builder.defineMacro("__R600__"); - if (GPUKind != llvm::AMDGPU::GK_NONE) { - StringRef CanonName = isAMDGCN(getTriple()) ? - getArchNameAMDGCN(GPUKind) : getArchNameR600(GPUKind); - Builder.defineMacro(Twine("__") + Twine(CanonName) + Twine("__")); - // Emit macros for gfx family e.g. gfx906 -> __GFX9__, gfx1030 -> __GFX10___ - if (isAMDGCN(getTriple())) { - assert(CanonName.starts_with("gfx") && "Invalid amdgcn canonical name"); - Builder.defineMacro(Twine("__") + Twine(CanonName.drop_back(2).upper()) + - Twine("__")); - } - if (isAMDGCN(getTriple())) { - Builder.defineMacro("__amdgcn_processor__", - Twine("\"") + Twine(CanonName) + Twine("\"")); - Builder.defineMacro("__amdgcn_target_id__", - Twine("\"") + Twine(*getTargetID()) + Twine("\"")); - for (auto F : getAllPossibleTargetIDFeatures(getTriple(), CanonName)) { - auto Loc = OffloadArchFeatures.find(F); - if (Loc != OffloadArchFeatures.end()) { - std::string NewF = F.str(); - std::replace(NewF.begin(), NewF.end(), '-', '_'); - Builder.defineMacro(Twine("__amdgcn_feature_") + Twine(NewF) + - Twine("__"), - Loc->second ? "1" : "0"); - } + // Legacy HIP host code relies on these default attributes to be defined. + bool IsHIPHost = Opts.HIP && !Opts.CUDAIsDevice; + if (GPUKind == llvm::AMDGPU::GK_NONE && !IsHIPHost) + return; + + llvm::SmallString<16> CanonName = + (isAMDGCN(getTriple()) ? getArchNameAMDGCN(GPUKind) + : getArchNameR600(GPUKind)); + + // Sanitize the name of generic targets. + // e.g. gfx10-1-generic -> gfx10_1_generic + if (GPUKind >= llvm::AMDGPU::GK_AMDGCN_GENERIC_FIRST && + GPUKind <= llvm::AMDGPU::GK_AMDGCN_GENERIC_LAST) { + std::replace(CanonName.begin(), CanonName.end(), '-', '_'); + } + + Builder.defineMacro(Twine("__") + Twine(CanonName) + Twine("__")); + // Emit macros for gfx family e.g. gfx906 -> __GFX9__, gfx1030 -> __GFX10___ + if (isAMDGCN(getTriple()) && !IsHIPHost) { + assert(StringRef(CanonName).starts_with("gfx") && + "Invalid amdgcn canonical name"); + StringRef CanonFamilyName = getArchFamilyNameAMDGCN(GPUKind); + Builder.defineMacro(Twine("__") + Twine(CanonFamilyName.upper()) + + Twine("__")); + Builder.defineMacro("__amdgcn_processor__", + Twine("\"") + Twine(CanonName) + Twine("\"")); + Builder.defineMacro("__amdgcn_target_id__", + Twine("\"") + Twine(*getTargetID()) + Twine("\"")); + for (auto F : getAllPossibleTargetIDFeatures(getTriple(), CanonName)) { + auto Loc = OffloadArchFeatures.find(F); + if (Loc != OffloadArchFeatures.end()) { + std::string NewF = F.str(); + std::replace(NewF.begin(), NewF.end(), '-', '_'); + Builder.defineMacro(Twine("__amdgcn_feature_") + Twine(NewF) + + Twine("__"), + Loc->second ? "1" : "0"); } } } diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/AMDGPU.h b/contrib/llvm-project/clang/lib/Basic/Targets/AMDGPU.h index 90a1516ecdd2..94d9ba93ed22 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/AMDGPU.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/AMDGPU.h @@ -168,9 +168,7 @@ public: return true; } - bool HasLeftParen = false; - if (S.consume_front("{")) - HasLeftParen = true; + bool HasLeftParen = S.consume_front("{"); if (S.empty()) return false; if (S.front() != 'v' && S.front() != 's' && S.front() != 'a') { @@ -196,9 +194,7 @@ public: Name = S.data() - 1; return true; } - bool HasLeftBracket = false; - if (S.consume_front("[")) - HasLeftBracket = true; + bool HasLeftBracket = S.consume_front("["); unsigned long long N; if (S.empty() || consumeUnsignedInteger(S, 10, N)) return false; @@ -418,8 +414,10 @@ public: // value ~0. uint64_t getNullPointerValue(LangAS AS) const override { // FIXME: Also should handle region. - return (AS == LangAS::opencl_local || AS == LangAS::opencl_private) - ? ~0 : 0; + return (AS == LangAS::opencl_local || AS == LangAS::opencl_private || + AS == LangAS::sycl_local || AS == LangAS::sycl_private) + ? ~0 + : 0; } void setAuxTarget(const TargetInfo *Aux) override; diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/ARM.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/ARM.cpp index 55b71557452f..e55feedbd5c6 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/ARM.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/ARM.cpp @@ -173,8 +173,7 @@ bool ARMTargetInfo::supportsThumb() const { } bool ARMTargetInfo::supportsThumb2() const { - return CPUAttr.equals("6T2") || - (ArchVersion >= 7 && !CPUAttr.equals("8M_BASE")); + return CPUAttr == "6T2" || (ArchVersion >= 7 && CPUAttr != "8M_BASE"); } StringRef ARMTargetInfo::getCPUAttr() const { @@ -312,7 +311,9 @@ ARMTargetInfo::ARMTargetInfo(const llvm::Triple &Triple, switch (Triple.getEnvironment()) { case llvm::Triple::Android: case llvm::Triple::GNUEABI: + case llvm::Triple::GNUEABIT64: case llvm::Triple::GNUEABIHF: + case llvm::Triple::GNUEABIHFT64: case llvm::Triple::MuslEABI: case llvm::Triple::MuslEABIHF: case llvm::Triple::OpenHOS: @@ -509,7 +510,7 @@ bool ARMTargetInfo::handleTargetFeatures(std::vector<std::string> &Features, SHA2 = 0; AES = 0; DSP = 0; - Unaligned = 1; + HasUnalignedAccess = true; SoftFloat = false; // Note that SoftFloatABI is initialized in our constructor. HWDiv = 0; @@ -576,7 +577,7 @@ bool ARMTargetInfo::handleTargetFeatures(std::vector<std::string> &Features, return false; } } else if (Feature == "+strict-align") { - Unaligned = 0; + HasUnalignedAccess = false; } else if (Feature == "+fp16") { HW_FP |= HW_FP_HP; } else if (Feature == "+fullfp16") { @@ -785,7 +786,7 @@ void ARMTargetInfo::getTargetDefines(const LangOptions &Opts, Builder.defineMacro("__ARM_ARCH_PROFILE", "'" + CPUProfile + "'"); // ACLE 6.4.3 Unaligned access supported in hardware - if (Unaligned) + if (HasUnalignedAccess) Builder.defineMacro("__ARM_FEATURE_UNALIGNED", "1"); // ACLE 6.4.4 LDREX/STREX @@ -1162,7 +1163,7 @@ bool ARMTargetInfo::validateAsmConstraint( return true; case 'j': // An immediate integer between 0 and 65535 (valid for MOVW) // only available in ARMv6T2 and above - if (CPUAttr.equals("6T2") || ArchVersion >= 7) { + if (CPUAttr == "6T2" || ArchVersion >= 7) { Info.setRequiresImmediate(0, 65535); return true; } diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/ARM.h b/contrib/llvm-project/clang/lib/Basic/Targets/ARM.h index 9802eb01abf3..df9855a52e61 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/ARM.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/ARM.h @@ -61,26 +61,41 @@ class LLVM_LIBRARY_VISIBILITY ARMTargetInfo : public TargetInfo { llvm::ARM::ProfileKind ArchProfile; unsigned ArchVersion; + LLVM_PREFERRED_TYPE(FPUMode) unsigned FPU : 5; + LLVM_PREFERRED_TYPE(MVEMode) unsigned MVE : 2; + LLVM_PREFERRED_TYPE(bool) unsigned IsAAPCS : 1; + LLVM_PREFERRED_TYPE(HWDivMode) unsigned HWDiv : 2; // Initialized via features. + LLVM_PREFERRED_TYPE(bool) unsigned SoftFloat : 1; + LLVM_PREFERRED_TYPE(bool) unsigned SoftFloatABI : 1; + LLVM_PREFERRED_TYPE(bool) unsigned CRC : 1; + LLVM_PREFERRED_TYPE(bool) unsigned Crypto : 1; + LLVM_PREFERRED_TYPE(bool) unsigned SHA2 : 1; + LLVM_PREFERRED_TYPE(bool) unsigned AES : 1; + LLVM_PREFERRED_TYPE(bool) unsigned DSP : 1; - unsigned Unaligned : 1; + LLVM_PREFERRED_TYPE(bool) unsigned DotProd : 1; + LLVM_PREFERRED_TYPE(bool) unsigned HasMatMul : 1; + LLVM_PREFERRED_TYPE(bool) unsigned FPRegsDisabled : 1; + LLVM_PREFERRED_TYPE(bool) unsigned HasPAC : 1; + LLVM_PREFERRED_TYPE(bool) unsigned HasBTI : 1; enum { @@ -210,6 +225,10 @@ public: bool hasBitIntType() const override { return true; } const char *getBFloat16Mangling() const override { return "u6__bf16"; }; + + std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override { + return std::make_pair(getTriple().isArch64Bit() ? 256 : 64, 64); + } }; class LLVM_LIBRARY_VISIBILITY ARMleTargetInfo : public ARMTargetInfo { diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/AVR.h b/contrib/llvm-project/clang/lib/Basic/Targets/AVR.h index 9376c46cd98c..feeb04f37eeb 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/AVR.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/AVR.h @@ -175,6 +175,10 @@ public: std::optional<std::string> handleAsmEscapedChar(char EscChar) const override; StringRef getABI() const override { return ABI; } + std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override { + return std::make_pair(32, 32); + } + protected: std::string CPU; StringRef ABI; diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/BPF.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/BPF.cpp index e713e0847922..b5ba11a3bdca 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/BPF.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/BPF.cpp @@ -22,7 +22,7 @@ using namespace clang::targets; static constexpr Builtin::Info BuiltinInfo[] = { #define BUILTIN(ID, TYPE, ATTRS) \ {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES}, -#include "clang/Basic/BuiltinsBPF.def" +#include "clang/Basic/BuiltinsBPF.inc" }; void BPFTargetInfo::getTargetDefines(const LangOptions &Opts, @@ -35,6 +35,9 @@ void BPFTargetInfo::getTargetDefines(const LangOptions &Opts, Builder.defineMacro("__BPF_CPU_VERSION__", "0"); return; } + + Builder.defineMacro("__BPF_FEATURE_ADDR_SPACE_CAST"); + if (CPU.empty() || CPU == "generic" || CPU == "v1") { Builder.defineMacro("__BPF_CPU_VERSION__", "1"); return; @@ -42,6 +45,7 @@ void BPFTargetInfo::getTargetDefines(const LangOptions &Opts, std::string CpuVerNumStr = CPU.substr(1); Builder.defineMacro("__BPF_CPU_VERSION__", CpuVerNumStr); + Builder.defineMacro("__BPF_FEATURE_MAY_GOTO"); int CpuVerNum = std::stoi(CpuVerNumStr); if (CpuVerNum >= 2) diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/BPF.h b/contrib/llvm-project/clang/lib/Basic/Targets/BPF.h index 489f29fc4fea..d19b37dd4df7 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/BPF.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/BPF.h @@ -113,6 +113,10 @@ public: StringRef CPUName(Name); return isValidCPUName(CPUName); } + + std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override { + return std::make_pair(32, 32); + } }; } // namespace targets } // namespace clang diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/CSKY.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/CSKY.cpp index 851f27dbb1e5..c8bf8b9234d2 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/CSKY.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/CSKY.cpp @@ -308,7 +308,8 @@ bool CSKYTargetInfo::validateAsmConstraint( } } -unsigned CSKYTargetInfo::getMinGlobalAlign(uint64_t Size) const { +unsigned CSKYTargetInfo::getMinGlobalAlign(uint64_t Size, + bool HasNonWeakDef) const { if (Size >= 32) return 32; return 0; diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/CSKY.h b/contrib/llvm-project/clang/lib/Basic/Targets/CSKY.h index 11404e37db36..94d4eeb9a1ff 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/CSKY.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/CSKY.h @@ -71,7 +71,7 @@ public: bool isValidCPUName(StringRef Name) const override; - unsigned getMinGlobalAlign(uint64_t) const override; + unsigned getMinGlobalAlign(uint64_t, bool HasNonWeakDef) const override; ArrayRef<Builtin::Info> getTargetBuiltins() const override; diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/DirectX.h b/contrib/llvm-project/clang/lib/Basic/Targets/DirectX.h index acfcc8c47ba9..a084e2823453 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/DirectX.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/DirectX.h @@ -53,7 +53,6 @@ public: : TargetInfo(Triple) { TLSSupported = false; VLASupported = false; - LongWidth = LongAlign = 64; AddrSpaceMap = &DirectXAddrSpaceMap; UseAddrSpaceMapMangling = true; HasLegalHalfType = true; diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/Hexagon.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/Hexagon.cpp index ac747e371fb4..0282ac812c30 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/Hexagon.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/Hexagon.cpp @@ -238,6 +238,18 @@ static constexpr CPUSuffix Suffixes[] = { {{"hexagonv73"}, {"73"}}, }; +std::optional<unsigned> HexagonTargetInfo::getHexagonCPURev(StringRef Name) { + StringRef Arch = Name; + Arch.consume_front("hexagonv"); + Arch.consume_back("t"); + + unsigned Val; + if (!Arch.getAsInteger(0, Val)) + return Val; + + return std::nullopt; +} + const char *HexagonTargetInfo::getHexagonCPUSuffix(StringRef Name) { const CPUSuffix *Item = llvm::find_if( Suffixes, [Name](const CPUSuffix &S) { return S.Name == Name; }); diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/Hexagon.h b/contrib/llvm-project/clang/lib/Basic/Targets/Hexagon.h index cdb47dbae799..7f053ab7e488 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/Hexagon.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/Hexagon.h @@ -17,6 +17,7 @@ #include "clang/Basic/TargetOptions.h" #include "llvm/Support/Compiler.h" #include "llvm/TargetParser/Triple.h" +#include <optional> namespace clang { namespace targets { @@ -115,6 +116,7 @@ public: std::string_view getClobbers() const override { return ""; } static const char *getHexagonCPUSuffix(StringRef Name); + static std::optional<unsigned> getHexagonCPURev(StringRef Name); bool isValidCPUName(StringRef Name) const override { return getHexagonCPUSuffix(Name); @@ -139,6 +141,14 @@ public: } bool hasBitIntType() const override { return true; } + + std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override { + std::optional<unsigned> Rev = getHexagonCPURev(CPU); + + // V73 and later have 64-byte cache lines. + unsigned CacheLineSizeBytes = Rev >= 73U ? 64 : 32; + return std::make_pair(CacheLineSizeBytes, CacheLineSizeBytes); + } }; } // namespace targets } // namespace clang diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/LoongArch.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/LoongArch.cpp index 88537989a051..cb3fd12c48dd 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/LoongArch.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/LoongArch.cpp @@ -200,7 +200,24 @@ void LoongArchTargetInfo::getTargetDefines(const LangOptions &Opts, // Define __loongarch_arch. StringRef ArchName = getCPU(); - Builder.defineMacro("__loongarch_arch", Twine('"') + ArchName + Twine('"')); + if (ArchName == "loongarch64") { + if (HasFeatureLSX) { + // TODO: As more features of the V1.1 ISA are supported, a unified "v1.1" + // arch feature set will be used to include all sub-features belonging to + // the V1.1 ISA version. + if (HasFeatureFrecipe) + Builder.defineMacro("__loongarch_arch", + Twine('"') + "la64v1.1" + Twine('"')); + else + Builder.defineMacro("__loongarch_arch", + Twine('"') + "la64v1.0" + Twine('"')); + } else { + Builder.defineMacro("__loongarch_arch", + Twine('"') + ArchName + Twine('"')); + } + } else { + Builder.defineMacro("__loongarch_arch", Twine('"') + ArchName + Twine('"')); + } // Define __loongarch_tune. StringRef TuneCPU = getTargetOpts().TuneCPU; @@ -208,10 +225,16 @@ void LoongArchTargetInfo::getTargetDefines(const LangOptions &Opts, TuneCPU = ArchName; Builder.defineMacro("__loongarch_tune", Twine('"') + TuneCPU + Twine('"')); - if (HasFeatureLSX) + if (HasFeatureLASX) { + Builder.defineMacro("__loongarch_simd_width", "256"); Builder.defineMacro("__loongarch_sx", Twine(1)); - if (HasFeatureLASX) Builder.defineMacro("__loongarch_asx", Twine(1)); + } else if (HasFeatureLSX) { + Builder.defineMacro("__loongarch_simd_width", "128"); + Builder.defineMacro("__loongarch_sx", Twine(1)); + } + if (HasFeatureFrecipe) + Builder.defineMacro("__loongarch_frecipe", Twine(1)); StringRef ABI = getABI(); if (ABI == "lp64d" || ABI == "lp64f" || ABI == "lp64s") @@ -285,6 +308,10 @@ bool LoongArchTargetInfo::handleTargetFeatures( HasFeatureLSX = true; else if (Feature == "+lasx") HasFeatureLASX = true; + else if (Feature == "-ual") + HasUnalignedAccess = false; + else if (Feature == "+frecipe") + HasFeatureFrecipe = true; } return true; } diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/LoongArch.h b/contrib/llvm-project/clang/lib/Basic/Targets/LoongArch.h index 3313102492cb..c668ca7eca04 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/LoongArch.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/LoongArch.h @@ -29,6 +29,7 @@ protected: bool HasFeatureF; bool HasFeatureLSX; bool HasFeatureLASX; + bool HasFeatureFrecipe; public: LoongArchTargetInfo(const llvm::Triple &Triple, const TargetOptions &) @@ -37,6 +38,7 @@ public: HasFeatureF = false; HasFeatureLSX = false; HasFeatureLASX = false; + HasFeatureFrecipe = false; LongDoubleWidth = 128; LongDoubleAlign = 128; LongDoubleFormat = &llvm::APFloat::IEEEquad(); @@ -132,7 +134,8 @@ public: : LoongArchTargetInfo(Triple, Opts) { LongWidth = LongAlign = PointerWidth = PointerAlign = 64; IntMaxType = Int64Type = SignedLong; - resetDataLayout("e-m:e-p:64:64-i64:64-i128:128-n64-S128"); + HasUnalignedAccess = true; + resetDataLayout("e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"); // TODO: select appropriate ABI. setABI("lp64d"); } diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/M68k.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/M68k.cpp index 1b7e0a7f32c9..8b8bf97d6f99 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/M68k.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/M68k.cpp @@ -127,16 +127,21 @@ bool M68kTargetInfo::hasFeature(StringRef Feature) const { const char *const M68kTargetInfo::GCCRegNames[] = { "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", - "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", + "a0", "a1", "a2", "a3", "a4", "a5", "a6", "sp", "pc"}; ArrayRef<const char *> M68kTargetInfo::getGCCRegNames() const { return llvm::ArrayRef(GCCRegNames); } +const TargetInfo::GCCRegAlias M68kTargetInfo::GCCRegAliases[] = { + {{"bp"}, "a5"}, + {{"fp"}, "a6"}, + {{"usp", "ssp", "isp", "a7"}, "sp"}, +}; + ArrayRef<TargetInfo::GCCRegAlias> M68kTargetInfo::getGCCRegAliases() const { - // No aliases. - return std::nullopt; + return llvm::ArrayRef(GCCRegAliases); } bool M68kTargetInfo::validateAsmConstraint( diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/M68k.h b/contrib/llvm-project/clang/lib/Basic/Targets/M68k.h index a9c262e62fba..b732add77e03 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/M68k.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/M68k.h @@ -25,6 +25,7 @@ namespace targets { class LLVM_LIBRARY_VISIBILITY M68kTargetInfo : public TargetInfo { static const char *const GCCRegNames[]; + static const TargetInfo::GCCRegAlias GCCRegAliases[]; enum CPUKind { CK_Unknown, @@ -55,6 +56,10 @@ public: BuiltinVaListKind getBuiltinVaListKind() const override; bool setCPU(const std::string &Name) override; CallingConvCheckResult checkCallingConvention(CallingConv CC) const override; + + std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override { + return std::make_pair(32, 32); + } }; } // namespace targets diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/Mips.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/Mips.cpp index 3a65f53c5248..174bc9d2ab99 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/Mips.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/Mips.cpp @@ -273,6 +273,34 @@ bool MipsTargetInfo::validateTarget(DiagnosticsEngine &Diags) const { Diags.Report(diag::err_mips_fp64_req) << "-mfp64"; return false; } + // FPXX requires mips2+ + if (FPMode == FPXX && CPU == "mips1") { + Diags.Report(diag::err_opt_not_valid_with_opt) << "-mfpxx" << CPU; + return false; + } + // -mmsa with -msoft-float makes nonsense + if (FloatABI == SoftFloat && HasMSA) { + Diags.Report(diag::err_opt_not_valid_with_opt) << "-msoft-float" + << "-mmsa"; + return false; + } + // Option -mmsa permitted on Mips32 iff revision 2 or higher is present + if (HasMSA && (CPU == "mips1" || CPU == "mips2" || getISARev() < 2) && + ABI == "o32") { + Diags.Report(diag::err_mips_fp64_req) << "-mmsa"; + return false; + } + // MSA requires FP64 + if (FPMode == FPXX && HasMSA) { + Diags.Report(diag::err_opt_not_valid_with_opt) << "-mfpxx" + << "-mmsa"; + return false; + } + if (FPMode == FP32 && HasMSA) { + Diags.Report(diag::err_opt_not_valid_with_opt) << "-mfp32" + << "-mmsa"; + return false; + } return true; } diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/Mips.h b/contrib/llvm-project/clang/lib/Basic/Targets/Mips.h index 23d4e1b598fa..b6f110249fa7 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/Mips.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/Mips.h @@ -85,8 +85,13 @@ public: return CPU == "mips32r6" || CPU == "mips64r6"; } - bool isFP64Default() const { - return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64"; + enum FPModeEnum getDefaultFPMode() const { + if (CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64") + return FP64; + else if (CPU == "mips1") + return FP32; + else + return FPXX; } bool isNan2008() const override { return IsNan2008; } @@ -315,9 +320,11 @@ public: IsSingleFloat = false; FloatABI = HardFloat; DspRev = NoDSP; - FPMode = isFP64Default() ? FP64 : FPXX; NoOddSpreg = false; + FPMode = getDefaultFPMode(); bool OddSpregGiven = false; + bool StrictAlign = false; + bool FpGiven = false; for (const auto &Feature : Features) { if (Feature == "+single-float") @@ -328,6 +335,12 @@ public: IsMips16 = true; else if (Feature == "+micromips") IsMicromips = true; + else if (Feature == "+mips32r6" || Feature == "+mips64r6") + HasUnalignedAccess = true; + // We cannot be sure that the order of strict-align vs mips32r6. + // Thus we need an extra variable here. + else if (Feature == "+strict-align") + StrictAlign = true; else if (Feature == "+dsp") DspRev = std::max(DspRev, DSP1); else if (Feature == "+dspr2") @@ -336,13 +349,16 @@ public: HasMSA = true; else if (Feature == "+nomadd4") DisableMadd4 = true; - else if (Feature == "+fp64") + else if (Feature == "+fp64") { FPMode = FP64; - else if (Feature == "-fp64") + FpGiven = true; + } else if (Feature == "-fp64") { FPMode = FP32; - else if (Feature == "+fpxx") + FpGiven = true; + } else if (Feature == "+fpxx") { FPMode = FPXX; - else if (Feature == "+nan2008") + FpGiven = true; + } else if (Feature == "+nan2008") IsNan2008 = true; else if (Feature == "-nan2008") IsNan2008 = false; @@ -366,6 +382,14 @@ public: if (FPMode == FPXX && !OddSpregGiven) NoOddSpreg = true; + if (StrictAlign) + HasUnalignedAccess = false; + + if (HasMSA && !FpGiven) { + FPMode = FP64; + Features.push_back("+fp64"); + } + setDataLayout(); return true; @@ -421,6 +445,10 @@ public: bool validateTarget(DiagnosticsEngine &Diags) const override; bool hasBitIntType() const override { return true; } + + std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override { + return std::make_pair(32, 32); + } }; } // namespace targets } // namespace clang diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/NVPTX.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/NVPTX.cpp index c0b5db795e27..43b653dc52ce 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/NVPTX.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/NVPTX.cpp @@ -59,7 +59,11 @@ NVPTXTargetInfo::NVPTXTargetInfo(const llvm::Triple &Triple, // Define available target features // These must be defined in sorted order! NoAsmVariants = true; - GPU = CudaArch::SM_20; + GPU = OffloadArch::UNUSED; + + // PTX supports f16 as a fundamental type. + HasLegalHalfType = true; + HasFloat16 = true; if (TargetPointerWidth == 32) resetDataLayout("e-p:32:32-i64:64-i128:128-v16:16-v32:32-n16:32:64"); @@ -115,7 +119,8 @@ NVPTXTargetInfo::NVPTXTargetInfo(const llvm::Triple &Triple, LongAlign = HostTarget->getLongAlign(); LongLongWidth = HostTarget->getLongLongWidth(); LongLongAlign = HostTarget->getLongLongAlign(); - MinGlobalAlign = HostTarget->getMinGlobalAlign(/* TypeSize = */ 0); + MinGlobalAlign = HostTarget->getMinGlobalAlign(/* TypeSize = */ 0, + /* HasNonWeakDef = */ true); NewAlign = HostTarget->getNewAlign(); DefaultAlignForAttributeAligned = HostTarget->getDefaultAlignForAttributeAligned(); @@ -168,107 +173,119 @@ void NVPTXTargetInfo::getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const { Builder.defineMacro("__PTX__"); Builder.defineMacro("__NVPTX__"); + + // Skip setting architecture dependent macros if undefined. + if (GPU == OffloadArch::UNUSED && !HostTarget) + return; + if (Opts.CUDAIsDevice || Opts.OpenMPIsTargetDevice || !HostTarget) { // Set __CUDA_ARCH__ for the GPU specified. std::string CUDAArchCode = [this] { switch (GPU) { - case CudaArch::GFX600: - case CudaArch::GFX601: - case CudaArch::GFX602: - case CudaArch::GFX700: - case CudaArch::GFX701: - case CudaArch::GFX702: - case CudaArch::GFX703: - case CudaArch::GFX704: - case CudaArch::GFX705: - case CudaArch::GFX801: - case CudaArch::GFX802: - case CudaArch::GFX803: - case CudaArch::GFX805: - case CudaArch::GFX810: - case CudaArch::GFX900: - case CudaArch::GFX902: - case CudaArch::GFX904: - case CudaArch::GFX906: - case CudaArch::GFX908: - case CudaArch::GFX909: - case CudaArch::GFX90a: - case CudaArch::GFX90c: - case CudaArch::GFX940: - case CudaArch::GFX941: - case CudaArch::GFX942: - case CudaArch::GFX1010: - case CudaArch::GFX1011: - case CudaArch::GFX1012: - case CudaArch::GFX1013: - case CudaArch::GFX1030: - case CudaArch::GFX1031: - case CudaArch::GFX1032: - case CudaArch::GFX1033: - case CudaArch::GFX1034: - case CudaArch::GFX1035: - case CudaArch::GFX1036: - case CudaArch::GFX1100: - case CudaArch::GFX1101: - case CudaArch::GFX1102: - case CudaArch::GFX1103: - case CudaArch::GFX1150: - case CudaArch::GFX1151: - case CudaArch::GFX1200: - case CudaArch::GFX1201: - case CudaArch::Generic: - case CudaArch::LAST: + case OffloadArch::GFX600: + case OffloadArch::GFX601: + case OffloadArch::GFX602: + case OffloadArch::GFX700: + case OffloadArch::GFX701: + case OffloadArch::GFX702: + case OffloadArch::GFX703: + case OffloadArch::GFX704: + case OffloadArch::GFX705: + case OffloadArch::GFX801: + case OffloadArch::GFX802: + case OffloadArch::GFX803: + case OffloadArch::GFX805: + case OffloadArch::GFX810: + case OffloadArch::GFX9_GENERIC: + case OffloadArch::GFX900: + case OffloadArch::GFX902: + case OffloadArch::GFX904: + case OffloadArch::GFX906: + case OffloadArch::GFX908: + case OffloadArch::GFX909: + case OffloadArch::GFX90a: + case OffloadArch::GFX90c: + case OffloadArch::GFX940: + case OffloadArch::GFX941: + case OffloadArch::GFX942: + case OffloadArch::GFX10_1_GENERIC: + case OffloadArch::GFX1010: + case OffloadArch::GFX1011: + case OffloadArch::GFX1012: + case OffloadArch::GFX1013: + case OffloadArch::GFX10_3_GENERIC: + case OffloadArch::GFX1030: + case OffloadArch::GFX1031: + case OffloadArch::GFX1032: + case OffloadArch::GFX1033: + case OffloadArch::GFX1034: + case OffloadArch::GFX1035: + case OffloadArch::GFX1036: + case OffloadArch::GFX11_GENERIC: + case OffloadArch::GFX1100: + case OffloadArch::GFX1101: + case OffloadArch::GFX1102: + case OffloadArch::GFX1103: + case OffloadArch::GFX1150: + case OffloadArch::GFX1151: + case OffloadArch::GFX1152: + case OffloadArch::GFX12_GENERIC: + case OffloadArch::GFX1200: + case OffloadArch::GFX1201: + case OffloadArch::AMDGCNSPIRV: + case OffloadArch::Generic: + case OffloadArch::LAST: break; - case CudaArch::UNUSED: - case CudaArch::UNKNOWN: + case OffloadArch::UNKNOWN: assert(false && "No GPU arch when compiling CUDA device code."); return ""; - case CudaArch::SM_20: + case OffloadArch::UNUSED: + case OffloadArch::SM_20: return "200"; - case CudaArch::SM_21: + case OffloadArch::SM_21: return "210"; - case CudaArch::SM_30: + case OffloadArch::SM_30: return "300"; - case CudaArch::SM_32: + case OffloadArch::SM_32_: return "320"; - case CudaArch::SM_35: + case OffloadArch::SM_35: return "350"; - case CudaArch::SM_37: + case OffloadArch::SM_37: return "370"; - case CudaArch::SM_50: + case OffloadArch::SM_50: return "500"; - case CudaArch::SM_52: + case OffloadArch::SM_52: return "520"; - case CudaArch::SM_53: + case OffloadArch::SM_53: return "530"; - case CudaArch::SM_60: + case OffloadArch::SM_60: return "600"; - case CudaArch::SM_61: + case OffloadArch::SM_61: return "610"; - case CudaArch::SM_62: + case OffloadArch::SM_62: return "620"; - case CudaArch::SM_70: + case OffloadArch::SM_70: return "700"; - case CudaArch::SM_72: + case OffloadArch::SM_72: return "720"; - case CudaArch::SM_75: + case OffloadArch::SM_75: return "750"; - case CudaArch::SM_80: + case OffloadArch::SM_80: return "800"; - case CudaArch::SM_86: + case OffloadArch::SM_86: return "860"; - case CudaArch::SM_87: + case OffloadArch::SM_87: return "870"; - case CudaArch::SM_89: + case OffloadArch::SM_89: return "890"; - case CudaArch::SM_90: - case CudaArch::SM_90a: + case OffloadArch::SM_90: + case OffloadArch::SM_90a: return "900"; } - llvm_unreachable("unhandled CudaArch"); + llvm_unreachable("unhandled OffloadArch"); }(); Builder.defineMacro("__CUDA_ARCH__", CUDAArchCode); - if (GPU == CudaArch::SM_90a) + if (GPU == OffloadArch::SM_90a) Builder.defineMacro("__CUDA_ARCH_FEAT_SM90_ALL", "1"); } } diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/NVPTX.h b/contrib/llvm-project/clang/lib/Basic/Targets/NVPTX.h index 20d76b702a94..25dc979d882f 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/NVPTX.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/NVPTX.h @@ -62,7 +62,7 @@ static const int NVPTXDWARFAddrSpaceMap[] = { class LLVM_LIBRARY_VISIBILITY NVPTXTargetInfo : public TargetInfo { static const char *const GCCRegNames[]; - CudaArch GPU; + OffloadArch GPU; uint32_t PTXVersion; std::unique_ptr<TargetInfo> HostTarget; @@ -75,11 +75,14 @@ public: ArrayRef<Builtin::Info> getTargetBuiltins() const override; + bool useFP16ConversionIntrinsics() const override { return false; } + bool initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector<std::string> &FeaturesVec) const override { - Features[CudaArchToString(GPU)] = true; + if (GPU != OffloadArch::UNUSED) + Features[OffloadArchToString(GPU)] = true; Features["ptx" + std::to_string(PTXVersion)] = true; return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec); } @@ -104,6 +107,7 @@ public: case 'l': case 'f': case 'd': + case 'q': Info.setAllowsRegister(); return true; } @@ -115,23 +119,22 @@ public: } BuiltinVaListKind getBuiltinVaListKind() const override { - // FIXME: implement - return TargetInfo::CharPtrBuiltinVaList; + return TargetInfo::VoidPtrBuiltinVaList; } bool isValidCPUName(StringRef Name) const override { - return StringToCudaArch(Name) != CudaArch::UNKNOWN; + return StringToOffloadArch(Name) != OffloadArch::UNKNOWN; } void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override { - for (int i = static_cast<int>(CudaArch::SM_20); - i < static_cast<int>(CudaArch::Generic); ++i) - Values.emplace_back(CudaArchToString(static_cast<CudaArch>(i))); + for (int i = static_cast<int>(OffloadArch::SM_20); + i < static_cast<int>(OffloadArch::Generic); ++i) + Values.emplace_back(OffloadArchToString(static_cast<OffloadArch>(i))); } bool setCPU(const std::string &Name) override { - GPU = StringToCudaArch(Name); - return GPU != CudaArch::UNKNOWN; + GPU = StringToOffloadArch(Name); + return GPU != OffloadArch::UNKNOWN; } void setSupportedOpenCLOpts() override { @@ -182,7 +185,7 @@ public: bool hasBitIntType() const override { return true; } bool hasBFloat16Type() const override { return true; } - CudaArch getGPU() const { return GPU; } + OffloadArch getGPU() const { return GPU; } }; } // namespace targets } // namespace clang diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/OSTargets.h b/contrib/llvm-project/clang/lib/Basic/Targets/OSTargets.h index 4366c1149e40..357c1965057c 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/OSTargets.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/OSTargets.h @@ -337,6 +337,10 @@ protected: Builder.defineMacro("_GNU_SOURCE"); if (this->HasFloat128) Builder.defineMacro("__FLOAT128__"); + if (Triple.isTime64ABI()) { + Builder.defineMacro("_FILE_OFFSET_BITS", "64"); + Builder.defineMacro("_TIME_BITS", "64"); + } } public: @@ -868,6 +872,7 @@ protected: public: FuchsiaTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) : OSTargetInfo<Target>(Triple, Opts) { + this->WIntType = TargetInfo::UnsignedInt; this->MCountName = "__mcount"; this->TheCXXABI.set(TargetCXXABI::Fuchsia); } diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/PPC.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/PPC.cpp index 41935abfb65d..9ff54083c923 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/PPC.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/PPC.cpp @@ -79,6 +79,8 @@ bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features, HasPrivileged = true; } else if (Feature == "+aix-small-local-exec-tls") { HasAIXSmallLocalExecTLS = true; + } else if (Feature == "+aix-small-local-dynamic-tls") { + HasAIXSmallLocalDynamicTLS = true; } else if (Feature == "+isa-v206-instructions") { IsISA2_06 = true; } else if (Feature == "+isa-v207-instructions") { @@ -89,6 +91,10 @@ bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features, IsISA3_1 = true; } else if (Feature == "+quadword-atomics") { HasQuadwordAtomics = true; + } else if (Feature == "+aix-shared-lib-tls-model-opt") { + HasAIXShLibTLSModelOpt = true; + } else if (Feature == "+longcall") { + UseLongCalls = true; } // TODO: Finish this list and add an assert that we've handled them // all. @@ -379,6 +385,8 @@ void PPCTargetInfo::getTargetDefines(const LangOptions &Opts, Builder.defineMacro("_ARCH_PWR9"); if (ArchDefs & ArchDefinePwr10) Builder.defineMacro("_ARCH_PWR10"); + if (ArchDefs & ArchDefinePwr11) + Builder.defineMacro("_ARCH_PWR11"); if (ArchDefs & ArchDefineA2) Builder.defineMacro("_ARCH_A2"); if (ArchDefs & ArchDefineE500) @@ -442,19 +450,44 @@ void PPCTargetInfo::getTargetDefines(const LangOptions &Opts, // _CALL_DARWIN } -// Handle explicit options being passed to the compiler here: if we've -// explicitly turned off vsx and turned on any of: -// - power8-vector -// - direct-move -// - float128 -// - power9-vector -// - paired-vector-memops -// - mma -// - power10-vector +// Handle explicit options being passed to the compiler here: +// - if we've explicitly turned off vsx and turned on any of: +// - power8-vector +// - direct-move +// - float128 +// - power9-vector +// - paired-vector-memops +// - mma +// - power10-vector +// - if we've explicitly turned on vsx and turned off altivec. +// - if we've explicitly turned off hard-float and turned on altivec. // then go ahead and error since the customer has expressed an incompatible // set of options. static bool ppcUserFeaturesCheck(DiagnosticsEngine &Diags, const std::vector<std::string> &FeaturesVec) { + // Cannot allow soft-float with Altivec. + if (llvm::is_contained(FeaturesVec, "-hard-float") && + llvm::is_contained(FeaturesVec, "+altivec")) { + Diags.Report(diag::err_opt_not_valid_with_opt) << "-msoft-float" + << "-maltivec"; + return false; + } + + // Cannot allow soft-float with VSX. + if (llvm::is_contained(FeaturesVec, "-hard-float") && + llvm::is_contained(FeaturesVec, "+vsx")) { + Diags.Report(diag::err_opt_not_valid_with_opt) << "-msoft-float" + << "-mvsx"; + return false; + } + + // Cannot allow VSX with no Altivec. + if (llvm::is_contained(FeaturesVec, "+vsx") && + llvm::is_contained(FeaturesVec, "-altivec")) { + Diags.Report(diag::err_opt_not_valid_with_opt) << "-mvsx" + << "-mno-altivec"; + return false; + } // vsx was not explicitly turned off. if (!llvm::is_contained(FeaturesVec, "-vsx")) @@ -548,9 +581,13 @@ bool PPCTargetInfo::initFeatureMap( // Privileged instructions are off by default. Features["privileged"] = false; - // The code generated by the -maix-small-local-exec-tls option is turned - // off by default. + // The code generated by the -maix-small-local-[exec|dynamic]-tls option is + // turned off by default. Features["aix-small-local-exec-tls"] = false; + Features["aix-small-local-dynamic-tls"] = false; + + // Turn off TLS model opt by default. + Features["aix-shared-lib-tls-model-opt"] = false; Features["spe"] = llvm::StringSwitch<bool>(CPU) .Case("8548", true) @@ -587,10 +624,17 @@ bool PPCTargetInfo::initFeatureMap( addP10SpecificFeatures(Features); } - // Future CPU should include all of the features of Power 10 as well as any + // Power11 includes all the same features as Power10 plus any features + // specific to the Power11 core. + if (CPU == "pwr11" || CPU == "power11") { + initFeatureMap(Features, Diags, "pwr10", FeaturesVec); + addP11SpecificFeatures(Features); + } + + // Future CPU should include all of the features of Power 11 as well as any // additional features (yet to be determined) specific to it. if (CPU == "future") { - initFeatureMap(Features, Diags, "pwr10", FeaturesVec); + initFeatureMap(Features, Diags, "pwr11", FeaturesVec); addFutureSpecificFeatures(Features); } @@ -646,14 +690,6 @@ bool PPCTargetInfo::initFeatureMap( return false; } - if (llvm::is_contained(FeaturesVec, "+aix-small-local-exec-tls")) { - if (!getTriple().isOSAIX() || !getTriple().isArch64Bit()) { - Diags.Report(diag::err_opt_not_valid_on_target) - << "-maix-small-local-exec-tls"; - return false; - } - } - return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec); } @@ -669,6 +705,10 @@ void PPCTargetInfo::addP10SpecificFeatures( Features["isa-v31-instructions"] = true; } +// Add any Power11 specific features. +void PPCTargetInfo::addP11SpecificFeatures( + llvm::StringMap<bool> &Features) const {} + // Add features specific to the "Future" CPU. void PPCTargetInfo::addFutureSpecificFeatures( llvm::StringMap<bool> &Features) const {} @@ -696,11 +736,14 @@ bool PPCTargetInfo::hasFeature(StringRef Feature) const { .Case("rop-protect", HasROPProtect) .Case("privileged", HasPrivileged) .Case("aix-small-local-exec-tls", HasAIXSmallLocalExecTLS) + .Case("aix-small-local-dynamic-tls", HasAIXSmallLocalDynamicTLS) .Case("isa-v206-instructions", IsISA2_06) .Case("isa-v207-instructions", IsISA2_07) .Case("isa-v30-instructions", IsISA3_0) .Case("isa-v31-instructions", IsISA3_1) .Case("quadword-atomics", HasQuadwordAtomics) + .Case("aix-shared-lib-tls-model-opt", HasAIXShLibTLSModelOpt) + .Case("longcall", UseLongCalls) .Default(false); } @@ -840,17 +883,17 @@ ArrayRef<TargetInfo::AddlRegName> PPCTargetInfo::getGCCAddlRegNames() const { } static constexpr llvm::StringLiteral ValidCPUNames[] = { - {"generic"}, {"440"}, {"450"}, {"601"}, {"602"}, - {"603"}, {"603e"}, {"603ev"}, {"604"}, {"604e"}, - {"620"}, {"630"}, {"g3"}, {"7400"}, {"g4"}, - {"7450"}, {"g4+"}, {"750"}, {"8548"}, {"970"}, - {"g5"}, {"a2"}, {"e500"}, {"e500mc"}, {"e5500"}, - {"power3"}, {"pwr3"}, {"power4"}, {"pwr4"}, {"power5"}, - {"pwr5"}, {"power5x"}, {"pwr5x"}, {"power6"}, {"pwr6"}, - {"power6x"}, {"pwr6x"}, {"power7"}, {"pwr7"}, {"power8"}, - {"pwr8"}, {"power9"}, {"pwr9"}, {"power10"}, {"pwr10"}, - {"powerpc"}, {"ppc"}, {"ppc32"}, {"powerpc64"}, {"ppc64"}, - {"powerpc64le"}, {"ppc64le"}, {"future"}}; + {"generic"}, {"440"}, {"450"}, {"601"}, {"602"}, + {"603"}, {"603e"}, {"603ev"}, {"604"}, {"604e"}, + {"620"}, {"630"}, {"g3"}, {"7400"}, {"g4"}, + {"7450"}, {"g4+"}, {"750"}, {"8548"}, {"970"}, + {"g5"}, {"a2"}, {"e500"}, {"e500mc"}, {"e5500"}, + {"power3"}, {"pwr3"}, {"power4"}, {"pwr4"}, {"power5"}, + {"pwr5"}, {"power5x"}, {"pwr5x"}, {"power6"}, {"pwr6"}, + {"power6x"}, {"pwr6x"}, {"power7"}, {"pwr7"}, {"power8"}, + {"pwr8"}, {"power9"}, {"pwr9"}, {"power10"}, {"pwr10"}, + {"power11"}, {"pwr11"}, {"powerpc"}, {"ppc"}, {"ppc32"}, + {"powerpc64"}, {"ppc64"}, {"powerpc64le"}, {"ppc64le"}, {"future"}}; bool PPCTargetInfo::isValidCPUName(StringRef Name) const { return llvm::is_contained(ValidCPUNames, Name); @@ -878,3 +921,41 @@ ArrayRef<Builtin::Info> PPCTargetInfo::getTargetBuiltins() const { return llvm::ArrayRef(BuiltinInfo, clang::PPC::LastTSBuiltin - Builtin::FirstTSBuiltin); } + +bool PPCTargetInfo::validateCpuSupports(StringRef FeatureStr) const { + llvm::Triple Triple = getTriple(); + if (Triple.isOSAIX()) { +#define PPC_AIX_FEATURE(NAME, DESC, SUPPORT_METHOD, INDEX, MASK, COMP_OP, \ + VALUE) \ + .Case(NAME, true) + return llvm::StringSwitch<bool>(FeatureStr) +#include "llvm/TargetParser/PPCTargetParser.def" + .Default(false); + } + + assert(Triple.isOSLinux() && + "__builtin_cpu_supports() is only supported for AIX and Linux."); + +#define PPC_LNX_FEATURE(NAME, DESC, ENUMNAME, ENUMVAL, HWCAPN) .Case(NAME, true) + return llvm::StringSwitch<bool>(FeatureStr) +#include "llvm/TargetParser/PPCTargetParser.def" + .Default(false); +} + +bool PPCTargetInfo::validateCpuIs(StringRef CPUName) const { + llvm::Triple Triple = getTriple(); + assert((Triple.isOSAIX() || Triple.isOSLinux()) && + "__builtin_cpu_is() is only supported for AIX and Linux."); + +#define PPC_CPU(NAME, Linux_SUPPORT_METHOD, LinuxID, AIX_SUPPORT_METHOD, \ + AIXID) \ + .Case(NAME, {Linux_SUPPORT_METHOD, AIX_SUPPORT_METHOD}) + + std::pair<unsigned, unsigned> SuppportMethod = + llvm::StringSwitch<std::pair<unsigned, unsigned>>(CPUName) +#include "llvm/TargetParser/PPCTargetParser.def" + .Default({BUILTIN_PPC_UNSUPPORTED, BUILTIN_PPC_UNSUPPORTED}); + return Triple.isOSLinux() + ? (SuppportMethod.first != BUILTIN_PPC_UNSUPPORTED) + : (SuppportMethod.second != BUILTIN_PPC_UNSUPPORTED); +} diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/PPC.h b/contrib/llvm-project/clang/lib/Basic/Targets/PPC.h index 4d62673ba7fb..6d5d8dd54d01 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/PPC.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/PPC.h @@ -44,8 +44,9 @@ class LLVM_LIBRARY_VISIBILITY PPCTargetInfo : public TargetInfo { ArchDefinePwr8 = 1 << 12, ArchDefinePwr9 = 1 << 13, ArchDefinePwr10 = 1 << 14, - ArchDefineFuture = 1 << 15, - ArchDefineA2 = 1 << 16, + ArchDefinePwr11 = 1 << 15, + ArchDefineFuture = 1 << 16, + ArchDefineA2 = 1 << 17, ArchDefineE500 = 1 << 18 } ArchDefineTypes; @@ -61,6 +62,7 @@ class LLVM_LIBRARY_VISIBILITY PPCTargetInfo : public TargetInfo { bool HasROPProtect = false; bool HasPrivileged = false; bool HasAIXSmallLocalExecTLS = false; + bool HasAIXSmallLocalDynamicTLS = false; bool HasVSX = false; bool UseCRBits = false; bool HasP8Vector = false; @@ -80,6 +82,8 @@ class LLVM_LIBRARY_VISIBILITY PPCTargetInfo : public TargetInfo { bool IsISA3_0 = false; bool IsISA3_1 = false; bool HasQuadwordAtomics = false; + bool HasAIXShLibTLSModelOpt = false; + bool UseLongCalls = false; protected: std::string ABI; @@ -92,6 +96,7 @@ public: LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble(); HasStrictFP = true; HasIbm128 = true; + HasUnalignedAccess = true; } // Set the language option for altivec based on our value. @@ -162,11 +167,16 @@ public: ArchDefinePwr7 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq) + .Cases("power11", "pwr11", + ArchDefinePwr11 | ArchDefinePwr10 | ArchDefinePwr9 | + ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6 | + ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4 | + ArchDefinePpcgr | ArchDefinePpcsq) .Case("future", - ArchDefineFuture | ArchDefinePwr10 | ArchDefinePwr9 | - ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6 | - ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4 | - ArchDefinePpcgr | ArchDefinePpcsq) + ArchDefineFuture | ArchDefinePwr11 | ArchDefinePwr10 | + ArchDefinePwr9 | ArchDefinePwr8 | ArchDefinePwr7 | + ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5 | + ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq) .Cases("8548", "e500", ArchDefineE500) .Default(ArchDefineNone); } @@ -188,6 +198,7 @@ public: const std::vector<std::string> &FeaturesVec) const override; void addP10SpecificFeatures(llvm::StringMap<bool> &Features) const; + void addP11SpecificFeatures(llvm::StringMap<bool> &Features) const; void addFutureSpecificFeatures(llvm::StringMap<bool> &Features) const; bool handleTargetFeatures(std::vector<std::string> &Features, @@ -302,9 +313,11 @@ public: // asm statements) Info.setAllowsMemory(); break; - case 'R': // AIX TOC entry case 'a': // Address operand that is an indexed or indirect from a // register (`p' is preferable for asm statements) + // TODO: Add full support for this constraint + return false; + case 'R': // AIX TOC entry case 'S': // Constant suitable as a 64-bit mask operand case 'T': // Constant suitable as a 32-bit mask operand case 'U': // System V Release 4 small data area reference @@ -357,8 +370,30 @@ public: bool hasBitIntType() const override { return true; } bool isSPRegName(StringRef RegName) const override { - return RegName.equals("r1") || RegName.equals("x1"); + return RegName == "r1" || RegName == "x1"; + } + + // We support __builtin_cpu_supports/__builtin_cpu_is on targets that + // have Glibc since it is Glibc that provides the HWCAP[2] in the auxv. + static constexpr int MINIMUM_AIX_OS_MAJOR = 7; + static constexpr int MINIMUM_AIX_OS_MINOR = 2; + bool supportsCpuSupports() const override { + llvm::Triple Triple = getTriple(); + // AIX 7.2 is the minimum requirement to support __builtin_cpu_supports(). + return Triple.isOSGlibc() || + (Triple.isOSAIX() && + !Triple.isOSVersionLT(MINIMUM_AIX_OS_MAJOR, MINIMUM_AIX_OS_MINOR)); } + + bool supportsCpuIs() const override { + llvm::Triple Triple = getTriple(); + // AIX 7.2 is the minimum requirement to support __builtin_cpu_is(). + return Triple.isOSGlibc() || + (Triple.isOSAIX() && + !Triple.isOSVersionLT(MINIMUM_AIX_OS_MAJOR, MINIMUM_AIX_OS_MINOR)); + } + bool validateCpuSupports(StringRef Feature) const override; + bool validateCpuIs(StringRef Name) const override; }; class LLVM_LIBRARY_VISIBILITY PPC32TargetInfo : public PPCTargetInfo { @@ -406,6 +441,10 @@ public: // This is the ELF definition return TargetInfo::PowerABIBuiltinVaList; } + + std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override { + return std::make_pair(32, 32); + } }; // Note: ABI differences may eventually require us to have a separate @@ -486,6 +525,10 @@ public: return CCCR_Warning; } } + + std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override { + return std::make_pair(128, 128); + } }; class LLVM_LIBRARY_VISIBILITY AIXPPC32TargetInfo : diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/RISCV.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/RISCV.cpp index c71b2e9eeb6c..9159162f01d1 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/RISCV.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/RISCV.cpp @@ -96,7 +96,8 @@ bool RISCVTargetInfo::validateAsmConstraint( // An address that is held in a general-purpose register. Info.setAllowsMemory(); return true; - case 'S': // A symbolic address + case 's': + case 'S': // A symbol or label reference with a constant offset Info.setAllowsRegister(); return true; case 'v': @@ -167,7 +168,7 @@ void RISCVTargetInfo::getTargetDefines(const LangOptions &Opts, Twine(getVersionValue(ExtInfo.Major, ExtInfo.Minor))); } - if (ISAInfo->hasExtension("m") || ISAInfo->hasExtension("zmmul")) + if (ISAInfo->hasExtension("zmmul")) Builder.defineMacro("__riscv_mul"); if (ISAInfo->hasExtension("m")) { @@ -210,7 +211,7 @@ void RISCVTargetInfo::getTargetDefines(const LangOptions &Opts, Builder.defineMacro("__riscv_v_fixed_vlen", Twine(VScale->first * llvm::RISCV::RVVBitsPerBlock)); - if (FastUnalignedAccess) + if (FastScalarUnalignedAccess) Builder.defineMacro("__riscv_misaligned_fast"); else Builder.defineMacro("__riscv_misaligned_avoid"); @@ -233,7 +234,7 @@ static constexpr Builtin::Info BuiltinInfo[] = { {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES}, #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \ {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES}, -#include "clang/Basic/BuiltinsRISCV.def" +#include "clang/Basic/BuiltinsRISCV.inc" }; ArrayRef<Builtin::Info> RISCVTargetInfo::getTargetBuiltins() const { @@ -352,7 +353,8 @@ bool RISCVTargetInfo::handleTargetFeatures(std::vector<std::string> &Features, if (ISAInfo->hasExtension("zfh") || ISAInfo->hasExtension("zhinx")) HasLegalHalfType = true; - FastUnalignedAccess = llvm::is_contained(Features, "+fast-unaligned-access"); + FastScalarUnalignedAccess = + llvm::is_contained(Features, "+unaligned-scalar-mem"); if (llvm::is_contained(Features, "+experimental")) HasExperimental = true; @@ -466,3 +468,14 @@ ParsedTargetAttr RISCVTargetInfo::parseTargetAttr(StringRef Features) const { } return Ret; } + +TargetInfo::CallingConvCheckResult +RISCVTargetInfo::checkCallingConvention(CallingConv CC) const { + switch (CC) { + default: + return CCCR_Warning; + case CC_C: + case CC_RISCVVectorCall: + return CCCR_OK; + } +} diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/RISCV.h b/contrib/llvm-project/clang/lib/Basic/Targets/RISCV.h index bfbdafb682c8..d5df6344bedc 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/RISCV.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/RISCV.h @@ -16,7 +16,7 @@ #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetOptions.h" #include "llvm/Support/Compiler.h" -#include "llvm/Support/RISCVISAInfo.h" +#include "llvm/TargetParser/RISCVISAInfo.h" #include "llvm/TargetParser/Triple.h" #include <optional> @@ -30,7 +30,7 @@ protected: std::unique_ptr<llvm::RISCVISAInfo> ISAInfo; private: - bool FastUnalignedAccess; + bool FastScalarUnalignedAccess; bool HasExperimental = false; public: @@ -110,6 +110,8 @@ public: bool hasBFloat16Type() const override { return true; } + CallingConvCheckResult checkCallingConvention(CallingConv CC) const override; + bool useFP16ConversionIntrinsics() const override { return false; } @@ -120,6 +122,10 @@ public: void fillValidTuneCPUList(SmallVectorImpl<StringRef> &Values) const override; bool supportsTargetAttributeTune() const override { return true; } ParsedTargetAttr parseTargetAttr(StringRef Str) const override; + + std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override { + return std::make_pair(32, 32); + } }; class LLVM_LIBRARY_VISIBILITY RISCV32TargetInfo : public RISCVTargetInfo { public: diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/SPIR.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/SPIR.cpp index dc920177d3a9..040303983594 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/SPIR.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/SPIR.cpp @@ -11,7 +11,9 @@ //===----------------------------------------------------------------------===// #include "SPIR.h" +#include "AMDGPU.h" #include "Targets.h" +#include "llvm/TargetParser/TargetParser.h" using namespace clang; using namespace clang::targets; @@ -54,3 +56,76 @@ void SPIRV64TargetInfo::getTargetDefines(const LangOptions &Opts, BaseSPIRVTargetInfo::getTargetDefines(Opts, Builder); DefineStd(Builder, "SPIRV64", Opts); } + +static const AMDGPUTargetInfo AMDGPUTI(llvm::Triple("amdgcn-amd-amdhsa"), {}); + +ArrayRef<const char *> SPIRV64AMDGCNTargetInfo::getGCCRegNames() const { + return AMDGPUTI.getGCCRegNames(); +} + +bool SPIRV64AMDGCNTargetInfo::initFeatureMap( + llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef, + const std::vector<std::string> &FeatureVec) const { + llvm::AMDGPU::fillAMDGPUFeatureMap({}, getTriple(), Features); + + return TargetInfo::initFeatureMap(Features, Diags, {}, FeatureVec); +} + +bool SPIRV64AMDGCNTargetInfo::validateAsmConstraint( + const char *&Name, TargetInfo::ConstraintInfo &Info) const { + return AMDGPUTI.validateAsmConstraint(Name, Info); +} + +std::string +SPIRV64AMDGCNTargetInfo::convertConstraint(const char *&Constraint) const { + return AMDGPUTI.convertConstraint(Constraint); +} + +ArrayRef<Builtin::Info> SPIRV64AMDGCNTargetInfo::getTargetBuiltins() const { + return AMDGPUTI.getTargetBuiltins(); +} + +void SPIRV64AMDGCNTargetInfo::getTargetDefines(const LangOptions &Opts, + MacroBuilder &Builder) const { + BaseSPIRVTargetInfo::getTargetDefines(Opts, Builder); + DefineStd(Builder, "SPIRV64", Opts); + + Builder.defineMacro("__AMD__"); + Builder.defineMacro("__AMDGPU__"); + Builder.defineMacro("__AMDGCN__"); +} + +void SPIRV64AMDGCNTargetInfo::setAuxTarget(const TargetInfo *Aux) { + assert(Aux && "Cannot invoke setAuxTarget without a valid auxiliary target!"); + + // This is a 1:1 copy of AMDGPUTargetInfo::setAuxTarget() + assert(HalfFormat == Aux->HalfFormat); + assert(FloatFormat == Aux->FloatFormat); + assert(DoubleFormat == Aux->DoubleFormat); + + // On x86_64 long double is 80-bit extended precision format, which is + // not supported by AMDGPU. 128-bit floating point format is also not + // supported by AMDGPU. Therefore keep its own format for these two types. + auto SaveLongDoubleFormat = LongDoubleFormat; + auto SaveFloat128Format = Float128Format; + auto SaveLongDoubleWidth = LongDoubleWidth; + auto SaveLongDoubleAlign = LongDoubleAlign; + copyAuxTarget(Aux); + LongDoubleFormat = SaveLongDoubleFormat; + Float128Format = SaveFloat128Format; + LongDoubleWidth = SaveLongDoubleWidth; + LongDoubleAlign = SaveLongDoubleAlign; + // For certain builtin types support on the host target, claim they are + // supported to pass the compilation of the host code during the device-side + // compilation. + // FIXME: As the side effect, we also accept `__float128` uses in the device + // code. To reject these builtin types supported in the host target but not in + // the device target, one approach would support `device_builtin` attribute + // so that we could tell the device builtin types from the host ones. This + // also solves the different representations of the same builtin type, such + // as `size_t` in the MSVC environment. + if (Aux->hasFloat128Type()) { + HasFloat128 = true; + Float128Format = DoubleFormat; + } +} diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/SPIR.h b/contrib/llvm-project/clang/lib/Basic/Targets/SPIR.h index fa4a3bb1c82e..37cf9d7921ba 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/SPIR.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/SPIR.h @@ -125,7 +125,9 @@ protected: LongAlign = HostTarget->getLongAlign(); LongLongWidth = HostTarget->getLongLongWidth(); LongLongAlign = HostTarget->getLongLongAlign(); - MinGlobalAlign = HostTarget->getMinGlobalAlign(/* TypeSize = */ 0); + MinGlobalAlign = + HostTarget->getMinGlobalAlign(/* TypeSize = */ 0, + /* HasNonWeakDef = */ true); NewAlign = HostTarget->getNewAlign(); DefaultAlignForAttributeAligned = HostTarget->getDefaultAlignForAttributeAligned(); @@ -257,7 +259,7 @@ public: SizeType = TargetInfo::UnsignedInt; PtrDiffType = IntPtrType = TargetInfo::SignedInt; resetDataLayout("e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-" - "v96:128-v192:256-v256:256-v512:512-v1024:1024"); + "v96:128-v192:256-v256:256-v512:512-v1024:1024-G1"); } void getTargetDefines(const LangOptions &Opts, @@ -274,7 +276,7 @@ public: SizeType = TargetInfo::UnsignedLong; PtrDiffType = IntPtrType = TargetInfo::SignedLong; resetDataLayout("e-i64:64-v16:16-v24:32-v32:32-v48:64-" - "v96:128-v192:256-v256:256-v512:512-v1024:1024"); + "v96:128-v192:256-v256:256-v512:512-v1024:1024-G1"); } void getTargetDefines(const LangOptions &Opts, @@ -308,11 +310,12 @@ public: assert(Triple.getEnvironment() >= llvm::Triple::Pixel && Triple.getEnvironment() <= llvm::Triple::Amplification && "Logical SPIR-V environment must be a valid shader stage."); + PointerWidth = PointerAlign = 64; // SPIR-V IDs are represented with a single 32-bit word. SizeType = TargetInfo::UnsignedInt; resetDataLayout("e-i64:64-v16:16-v24:32-v32:32-v48:64-" - "v96:128-v192:256-v256:256-v512:512-v1024:1024"); + "v96:128-v192:256-v256:256-v512:512-v1024:1024-G1"); } void getTargetDefines(const LangOptions &Opts, @@ -333,7 +336,7 @@ public: SizeType = TargetInfo::UnsignedInt; PtrDiffType = IntPtrType = TargetInfo::SignedInt; resetDataLayout("e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-" - "v96:128-v192:256-v256:256-v512:512-v1024:1024"); + "v96:128-v192:256-v256:256-v512:512-v1024:1024-G1"); } void getTargetDefines(const LangOptions &Opts, @@ -354,11 +357,62 @@ public: SizeType = TargetInfo::UnsignedLong; PtrDiffType = IntPtrType = TargetInfo::SignedLong; resetDataLayout("e-i64:64-v16:16-v24:32-v32:32-v48:64-" - "v96:128-v192:256-v256:256-v512:512-v1024:1024"); + "v96:128-v192:256-v256:256-v512:512-v1024:1024-G1"); + } + + void getTargetDefines(const LangOptions &Opts, + MacroBuilder &Builder) const override; +}; + +class LLVM_LIBRARY_VISIBILITY SPIRV64AMDGCNTargetInfo final + : public BaseSPIRVTargetInfo { +public: + SPIRV64AMDGCNTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) + : BaseSPIRVTargetInfo(Triple, Opts) { + assert(Triple.getArch() == llvm::Triple::spirv64 && + "Invalid architecture for 64-bit AMDGCN SPIR-V."); + assert(Triple.getVendor() == llvm::Triple::VendorType::AMD && + "64-bit AMDGCN SPIR-V target must use AMD vendor"); + assert(getTriple().getOS() == llvm::Triple::OSType::AMDHSA && + "64-bit AMDGCN SPIR-V target must use AMDHSA OS"); + assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment && + "64-bit SPIR-V target must use unknown environment type"); + PointerWidth = PointerAlign = 64; + SizeType = TargetInfo::UnsignedLong; + PtrDiffType = IntPtrType = TargetInfo::SignedLong; + + resetDataLayout("e-i64:64-v16:16-v24:32-v32:32-v48:64-" + "v96:128-v192:256-v256:256-v512:512-v1024:1024-G1-P4-A0"); + + BFloat16Width = BFloat16Align = 16; + BFloat16Format = &llvm::APFloat::BFloat(); + + HasLegalHalfType = true; + HasFloat16 = true; + HalfArgsAndReturns = true; } + bool hasBFloat16Type() const override { return true; } + + ArrayRef<const char *> getGCCRegNames() const override; + + bool initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, + StringRef, + const std::vector<std::string> &) const override; + + bool validateAsmConstraint(const char *&Name, + TargetInfo::ConstraintInfo &Info) const override; + + std::string convertConstraint(const char *&Constraint) const override; + + ArrayRef<Builtin::Info> getTargetBuiltins() const override; + void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override; + + void setAuxTarget(const TargetInfo *Aux) override; + + bool hasInt128Type() const override { return TargetInfo::hasInt128Type(); } }; } // namespace targets diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/Sparc.h b/contrib/llvm-project/clang/lib/Basic/Targets/Sparc.h index 214fef88e1dc..3357bee33e1a 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/Sparc.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/Sparc.h @@ -140,6 +140,10 @@ public: CPU = getCPUKind(Name); return CPU != CK_GENERIC; } + + std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override { + return std::make_pair(32, 32); + } }; // SPARC v8 is the 32-bit mode selected by Triple::sparc. diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/SystemZ.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/SystemZ.cpp index a9b5ca483861..06f08db2eadd 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/SystemZ.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/SystemZ.cpp @@ -138,6 +138,16 @@ bool SystemZTargetInfo::hasFeature(StringRef Feature) const { .Default(false); } +unsigned SystemZTargetInfo::getMinGlobalAlign(uint64_t Size, + bool HasNonWeakDef) const { + // Don't enforce the minimum alignment on an external or weak symbol if + // -munaligned-symbols is passed. + if (UnalignedSymbols && !HasNonWeakDef) + return 0; + + return MinGlobalAlign; +} + void SystemZTargetInfo::getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const { Builder.defineMacro("__s390__"); diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/SystemZ.h b/contrib/llvm-project/clang/lib/Basic/Targets/SystemZ.h index e4ec338880f2..3bc6f2c1d308 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/SystemZ.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/SystemZ.h @@ -29,11 +29,13 @@ class LLVM_LIBRARY_VISIBILITY SystemZTargetInfo : public TargetInfo { bool HasTransactionalExecution; bool HasVector; bool SoftFloat; + bool UnalignedSymbols; public: SystemZTargetInfo(const llvm::Triple &Triple, const TargetOptions &) : TargetInfo(Triple), CPU("z10"), ISARevision(8), - HasTransactionalExecution(false), HasVector(false), SoftFloat(false) { + HasTransactionalExecution(false), HasVector(false), SoftFloat(false), + UnalignedSymbols(false) { IntMaxType = SignedLong; Int64Type = SignedLong; IntWidth = IntAlign = 32; @@ -45,6 +47,7 @@ public: LongDoubleFormat = &llvm::APFloat::IEEEquad(); DefaultAlignForAttributeAligned = 64; MinGlobalAlign = 16; + HasUnalignedAccess = true; if (Triple.isOSzOS()) { TLSSupported = false; // All vector types are default aligned on an 8-byte boundary, even if the @@ -64,6 +67,8 @@ public: HasStrictFP = true; } + unsigned getMinGlobalAlign(uint64_t Size, bool HasNonWeakDef) const override; + void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override; @@ -79,7 +84,7 @@ public: ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override; bool isSPRegName(StringRef RegName) const override { - return RegName.equals("r15"); + return RegName == "r15"; } bool validateAsmConstraint(const char *&Name, @@ -163,6 +168,7 @@ public: HasTransactionalExecution = false; HasVector = false; SoftFloat = false; + UnalignedSymbols = false; for (const auto &Feature : Features) { if (Feature == "+transactional-execution") HasTransactionalExecution = true; @@ -170,6 +176,8 @@ public: HasVector = true; else if (Feature == "+soft-float") SoftFloat = true; + else if (Feature == "+unaligned-symbols") + UnalignedSymbols = true; } HasVector &= !SoftFloat; @@ -212,6 +220,10 @@ public: int getEHDataRegisterNumber(unsigned RegNo) const override { return RegNo < 4 ? 6 + RegNo : -1; } + + std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override { + return std::make_pair(256, 256); + } }; } // namespace targets } // namespace clang diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/VE.h b/contrib/llvm-project/clang/lib/Basic/Targets/VE.h index ea9a092cad80..7e8fdf6096ef 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/VE.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/VE.h @@ -40,6 +40,7 @@ public: Int64Type = SignedLong; RegParmMax = 8; MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; + HasUnalignedAccess = true; WCharType = UnsignedInt; WIntType = UnsignedInt; diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/WebAssembly.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/WebAssembly.cpp index f1c925d90cb6..1e565f0a5319 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/WebAssembly.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/WebAssembly.cpp @@ -45,19 +45,20 @@ bool WebAssemblyTargetInfo::setABI(const std::string &Name) { bool WebAssemblyTargetInfo::hasFeature(StringRef Feature) const { return llvm::StringSwitch<bool>(Feature) - .Case("simd128", SIMDLevel >= SIMD128) - .Case("relaxed-simd", SIMDLevel >= RelaxedSIMD) - .Case("nontrapping-fptoint", HasNontrappingFPToInt) - .Case("sign-ext", HasSignExt) - .Case("exception-handling", HasExceptionHandling) - .Case("bulk-memory", HasBulkMemory) .Case("atomics", HasAtomics) - .Case("mutable-globals", HasMutableGlobals) - .Case("multivalue", HasMultivalue) - .Case("tail-call", HasTailCall) - .Case("reference-types", HasReferenceTypes) + .Case("bulk-memory", HasBulkMemory) + .Case("exception-handling", HasExceptionHandling) .Case("extended-const", HasExtendedConst) + .Case("half-precision", HasHalfPrecision) .Case("multimemory", HasMultiMemory) + .Case("multivalue", HasMultivalue) + .Case("mutable-globals", HasMutableGlobals) + .Case("nontrapping-fptoint", HasNontrappingFPToInt) + .Case("reference-types", HasReferenceTypes) + .Case("relaxed-simd", SIMDLevel >= RelaxedSIMD) + .Case("sign-ext", HasSignExt) + .Case("simd128", SIMDLevel >= SIMD128) + .Case("tail-call", HasTailCall) .Default(false); } @@ -73,32 +74,34 @@ void WebAssemblyTargetInfo::fillValidCPUList( void WebAssemblyTargetInfo::getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const { defineCPUMacros(Builder, "wasm", /*Tuning=*/false); - if (SIMDLevel >= SIMD128) - Builder.defineMacro("__wasm_simd128__"); - if (SIMDLevel >= RelaxedSIMD) - Builder.defineMacro("__wasm_relaxed_simd__"); - if (HasNontrappingFPToInt) - Builder.defineMacro("__wasm_nontrapping_fptoint__"); - if (HasSignExt) - Builder.defineMacro("__wasm_sign_ext__"); - if (HasExceptionHandling) - Builder.defineMacro("__wasm_exception_handling__"); - if (HasBulkMemory) - Builder.defineMacro("__wasm_bulk_memory__"); if (HasAtomics) Builder.defineMacro("__wasm_atomics__"); - if (HasMutableGlobals) - Builder.defineMacro("__wasm_mutable_globals__"); - if (HasMultivalue) - Builder.defineMacro("__wasm_multivalue__"); - if (HasTailCall) - Builder.defineMacro("__wasm_tail_call__"); - if (HasReferenceTypes) - Builder.defineMacro("__wasm_reference_types__"); + if (HasBulkMemory) + Builder.defineMacro("__wasm_bulk_memory__"); + if (HasExceptionHandling) + Builder.defineMacro("__wasm_exception_handling__"); if (HasExtendedConst) Builder.defineMacro("__wasm_extended_const__"); if (HasMultiMemory) Builder.defineMacro("__wasm_multimemory__"); + if (HasHalfPrecision) + Builder.defineMacro("__wasm_half_precision__"); + if (HasMultivalue) + Builder.defineMacro("__wasm_multivalue__"); + if (HasMutableGlobals) + Builder.defineMacro("__wasm_mutable_globals__"); + if (HasNontrappingFPToInt) + Builder.defineMacro("__wasm_nontrapping_fptoint__"); + if (HasReferenceTypes) + Builder.defineMacro("__wasm_reference_types__"); + if (SIMDLevel >= RelaxedSIMD) + Builder.defineMacro("__wasm_relaxed_simd__"); + if (HasSignExt) + Builder.defineMacro("__wasm_sign_ext__"); + if (SIMDLevel >= SIMD128) + Builder.defineMacro("__wasm_simd128__"); + if (HasTailCall) + Builder.defineMacro("__wasm_tail_call__"); Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); @@ -147,19 +150,28 @@ void WebAssemblyTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features, bool WebAssemblyTargetInfo::initFeatureMap( llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector<std::string> &FeaturesVec) const { - if (CPU == "bleeding-edge") { - Features["nontrapping-fptoint"] = true; - Features["sign-ext"] = true; - Features["bulk-memory"] = true; - Features["atomics"] = true; + auto addGenericFeatures = [&]() { + Features["multivalue"] = true; Features["mutable-globals"] = true; - Features["tail-call"] = true; Features["reference-types"] = true; - Features["multimemory"] = true; - setSIMDLevel(Features, SIMD128, true); - } else if (CPU == "generic") { Features["sign-ext"] = true; - Features["mutable-globals"] = true; + }; + auto addBleedingEdgeFeatures = [&]() { + addGenericFeatures(); + Features["atomics"] = true; + Features["bulk-memory"] = true; + Features["exception-handling"] = true; + Features["extended-const"] = true; + Features["half-precision"] = true; + Features["multimemory"] = true; + Features["nontrapping-fptoint"] = true; + Features["tail-call"] = true; + setSIMDLevel(Features, RelaxedSIMD, true); + }; + if (CPU == "generic") { + addGenericFeatures(); + } else if (CPU == "bleeding-edge") { + addBleedingEdgeFeatures(); } return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec); @@ -168,36 +180,20 @@ bool WebAssemblyTargetInfo::initFeatureMap( bool WebAssemblyTargetInfo::handleTargetFeatures( std::vector<std::string> &Features, DiagnosticsEngine &Diags) { for (const auto &Feature : Features) { - if (Feature == "+simd128") { - SIMDLevel = std::max(SIMDLevel, SIMD128); - continue; - } - if (Feature == "-simd128") { - SIMDLevel = std::min(SIMDLevel, SIMDEnum(SIMD128 - 1)); - continue; - } - if (Feature == "+relaxed-simd") { - SIMDLevel = std::max(SIMDLevel, RelaxedSIMD); - continue; - } - if (Feature == "-relaxed-simd") { - SIMDLevel = std::min(SIMDLevel, SIMDEnum(RelaxedSIMD - 1)); - continue; - } - if (Feature == "+nontrapping-fptoint") { - HasNontrappingFPToInt = true; + if (Feature == "+atomics") { + HasAtomics = true; continue; } - if (Feature == "-nontrapping-fptoint") { - HasNontrappingFPToInt = false; + if (Feature == "-atomics") { + HasAtomics = false; continue; } - if (Feature == "+sign-ext") { - HasSignExt = true; + if (Feature == "+bulk-memory") { + HasBulkMemory = true; continue; } - if (Feature == "-sign-ext") { - HasSignExt = false; + if (Feature == "-bulk-memory") { + HasBulkMemory = false; continue; } if (Feature == "+exception-handling") { @@ -208,28 +204,29 @@ bool WebAssemblyTargetInfo::handleTargetFeatures( HasExceptionHandling = false; continue; } - if (Feature == "+bulk-memory") { - HasBulkMemory = true; + if (Feature == "+extended-const") { + HasExtendedConst = true; continue; } - if (Feature == "-bulk-memory") { - HasBulkMemory = false; + if (Feature == "-extended-const") { + HasExtendedConst = false; continue; } - if (Feature == "+atomics") { - HasAtomics = true; + if (Feature == "+half-precision") { + SIMDLevel = std::max(SIMDLevel, SIMD128); + HasHalfPrecision = true; continue; } - if (Feature == "-atomics") { - HasAtomics = false; + if (Feature == "-half-precision") { + HasHalfPrecision = false; continue; } - if (Feature == "+mutable-globals") { - HasMutableGlobals = true; + if (Feature == "+multimemory") { + HasMultiMemory = true; continue; } - if (Feature == "-mutable-globals") { - HasMutableGlobals = false; + if (Feature == "-multimemory") { + HasMultiMemory = false; continue; } if (Feature == "+multivalue") { @@ -240,12 +237,20 @@ bool WebAssemblyTargetInfo::handleTargetFeatures( HasMultivalue = false; continue; } - if (Feature == "+tail-call") { - HasTailCall = true; + if (Feature == "+mutable-globals") { + HasMutableGlobals = true; continue; } - if (Feature == "-tail-call") { - HasTailCall = false; + if (Feature == "-mutable-globals") { + HasMutableGlobals = false; + continue; + } + if (Feature == "+nontrapping-fptoint") { + HasNontrappingFPToInt = true; + continue; + } + if (Feature == "-nontrapping-fptoint") { + HasNontrappingFPToInt = false; continue; } if (Feature == "+reference-types") { @@ -256,20 +261,36 @@ bool WebAssemblyTargetInfo::handleTargetFeatures( HasReferenceTypes = false; continue; } - if (Feature == "+extended-const") { - HasExtendedConst = true; + if (Feature == "+relaxed-simd") { + SIMDLevel = std::max(SIMDLevel, RelaxedSIMD); continue; } - if (Feature == "-extended-const") { - HasExtendedConst = false; + if (Feature == "-relaxed-simd") { + SIMDLevel = std::min(SIMDLevel, SIMDEnum(RelaxedSIMD - 1)); continue; } - if (Feature == "+multimemory") { - HasMultiMemory = true; + if (Feature == "+sign-ext") { + HasSignExt = true; continue; } - if (Feature == "-multimemory") { - HasMultiMemory = false; + if (Feature == "-sign-ext") { + HasSignExt = false; + continue; + } + if (Feature == "+simd128") { + SIMDLevel = std::max(SIMDLevel, SIMD128); + continue; + } + if (Feature == "-simd128") { + SIMDLevel = std::min(SIMDLevel, SIMDEnum(SIMD128 - 1)); + continue; + } + if (Feature == "+tail-call") { + HasTailCall = true; + continue; + } + if (Feature == "-tail-call") { + HasTailCall = false; continue; } diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/WebAssembly.h b/contrib/llvm-project/clang/lib/Basic/Targets/WebAssembly.h index 83b1711f9fdf..e4a449d1ff30 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/WebAssembly.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/WebAssembly.h @@ -53,17 +53,18 @@ class LLVM_LIBRARY_VISIBILITY WebAssemblyTargetInfo : public TargetInfo { RelaxedSIMD, } SIMDLevel = NoSIMD; - bool HasNontrappingFPToInt = false; - bool HasSignExt = false; - bool HasExceptionHandling = false; - bool HasBulkMemory = false; bool HasAtomics = false; - bool HasMutableGlobals = false; - bool HasMultivalue = false; - bool HasTailCall = false; - bool HasReferenceTypes = false; + bool HasBulkMemory = false; + bool HasExceptionHandling = false; bool HasExtendedConst = false; + bool HasHalfPrecision = false; bool HasMultiMemory = false; + bool HasMultivalue = false; + bool HasMutableGlobals = false; + bool HasNontrappingFPToInt = false; + bool HasReferenceTypes = false; + bool HasSignExt = false; + bool HasTailCall = false; std::string ABI; @@ -84,10 +85,14 @@ public: SizeType = UnsignedLong; PtrDiffType = SignedLong; IntPtrType = SignedLong; + HasUnalignedAccess = true; } StringRef getABI() const override; bool setABI(const std::string &Name) override; + bool useFP16ConversionIntrinsics() const override { + return !HasHalfPrecision; + } protected: void getTargetDefines(const LangOptions &Opts, diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/X86.cpp b/contrib/llvm-project/clang/lib/Basic/Targets/X86.cpp index a68b662d9401..072c97e6c8c6 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/X86.cpp +++ b/contrib/llvm-project/clang/lib/Basic/Targets/X86.cpp @@ -64,6 +64,8 @@ static const char *const GCCRegNames[] = { "dr0", "dr1", "dr2", "dr3", "dr6", "dr7", "bnd0", "bnd1", "bnd2", "bnd3", "tmm0", "tmm1", "tmm2", "tmm3", "tmm4", "tmm5", "tmm6", "tmm7", + "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", + "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", }; const TargetInfo::AddlRegName AddlRegNames[] = { @@ -83,8 +85,23 @@ const TargetInfo::AddlRegName AddlRegNames[] = { {{"r13d", "r13w", "r13b"}, 43}, {{"r14d", "r14w", "r14b"}, 44}, {{"r15d", "r15w", "r15b"}, 45}, + {{"r16d", "r16w", "r16b"}, 165}, + {{"r17d", "r17w", "r17b"}, 166}, + {{"r18d", "r18w", "r18b"}, 167}, + {{"r19d", "r19w", "r19b"}, 168}, + {{"r20d", "r20w", "r20b"}, 169}, + {{"r21d", "r21w", "r21b"}, 170}, + {{"r22d", "r22w", "r22b"}, 171}, + {{"r23d", "r23w", "r23b"}, 172}, + {{"r24d", "r24w", "r24b"}, 173}, + {{"r25d", "r25w", "r25b"}, 174}, + {{"r26d", "r26w", "r26b"}, 175}, + {{"r27d", "r27w", "r27b"}, 176}, + {{"r28d", "r28w", "r28b"}, 177}, + {{"r29d", "r29w", "r29b"}, 178}, + {{"r30d", "r30w", "r30b"}, 179}, + {{"r31d", "r31w", "r31b"}, 180}, }; - } // namespace targets } // namespace clang @@ -139,7 +156,7 @@ bool X86TargetInfo::initFeatureMap( if (Feature.substr(1, 6) == "avx10.") { if (Feature[0] == '+') { HasAVX10 = true; - if (Feature.substr(Feature.size() - 3, 3) == "512") + if (StringRef(Feature).ends_with("512")) HasAVX10_512 = true; LastAVX10 = Feature; } else if (HasAVX10 && Feature == "-avx10.1-256") { @@ -151,7 +168,7 @@ bool X86TargetInfo::initFeatureMap( // Postpone AVX10 features handling after AVX512 settled. UpdatedAVX10FeaturesVec.push_back(Feature); continue; - } else if (!HasAVX512F && Feature.substr(0, 7) == "+avx512") { + } else if (!HasAVX512F && StringRef(Feature).starts_with("+avx512")) { HasAVX512F = true; LastAVX512 = Feature; } else if (HasAVX512F && Feature == "-avx512f") { @@ -241,7 +258,9 @@ bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, if (Feature[0] != '+') continue; - if (Feature == "+aes") { + if (Feature == "+mmx") { + HasMMX = true; + } else if (Feature == "+aes") { HasAES = true; } else if (Feature == "+vaes") { HasVAES = true; @@ -293,15 +312,9 @@ bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, HasAVX512VNNI = true; } else if (Feature == "+avx512bf16") { HasAVX512BF16 = true; - } else if (Feature == "+avx512er") { - HasAVX512ER = true; - Diags.Report(diag::warn_knl_knm_isa_support_removed); } else if (Feature == "+avx512fp16") { HasAVX512FP16 = true; HasLegalHalfType = true; - } else if (Feature == "+avx512pf") { - HasAVX512PF = true; - Diags.Report(diag::warn_knl_knm_isa_support_removed); } else if (Feature == "+avx512dq") { HasAVX512DQ = true; } else if (Feature == "+avx512bitalg") { @@ -358,9 +371,6 @@ bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, HasWBNOINVD = true; } else if (Feature == "+prefetchi") { HasPREFETCHI = true; - } else if (Feature == "+prefetchwt1") { - HasPREFETCHWT1 = true; - Diags.Report(diag::warn_knl_knm_isa_support_removed); } else if (Feature == "+clzero") { HasCLZERO = true; } else if (Feature == "+cldemote") { @@ -433,6 +443,8 @@ bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, HasFullBFloat16 = true; } else if (Feature == "+egpr") { HasEGPR = true; + } else if (Feature == "+inline-asm-use-gpr32") { + HasInlineAsmUseGPR32 = true; } else if (Feature == "+push2pop2") { HasPush2Pop2 = true; } else if (Feature == "+ppx") { @@ -441,8 +453,14 @@ bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, HasNDD = true; } else if (Feature == "+ccmp") { HasCCMP = true; + } else if (Feature == "+nf") { + HasNF = true; } else if (Feature == "+cf") { HasCF = true; + } else if (Feature == "+zu") { + HasZU = true; + } else if (Feature == "+branch-hint") { + HasBranchHint = true; } X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature) @@ -471,13 +489,6 @@ bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, // for bfloat16 arithmetic operations in the front-end. HasBFloat16 = SSELevel >= SSE2; - MMX3DNowEnum ThreeDNowLevel = llvm::StringSwitch<MMX3DNowEnum>(Feature) - .Case("+3dnowa", AMD3DNowAthlon) - .Case("+3dnow", AMD3DNow) - .Case("+mmx", MMX) - .Default(NoMMX3DNow); - MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel); - XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature) .Case("+xop", XOP) .Case("+fma4", FMA4) @@ -712,6 +723,9 @@ void X86TargetInfo::getTargetDefines(const LangOptions &Opts, case CK_ZNVER4: defineCPUMacros(Builder, "znver4"); break; + case CK_ZNVER5: + defineCPUMacros(Builder, "znver5"); + break; case CK_Geode: defineCPUMacros(Builder, "geode"); break; @@ -821,12 +835,8 @@ void X86TargetInfo::getTargetDefines(const LangOptions &Opts, Builder.defineMacro("__AVX512VNNI__"); if (HasAVX512BF16) Builder.defineMacro("__AVX512BF16__"); - if (HasAVX512ER) - Builder.defineMacro("__AVX512ER__"); if (HasAVX512FP16) Builder.defineMacro("__AVX512FP16__"); - if (HasAVX512PF) - Builder.defineMacro("__AVX512PF__"); if (HasAVX512DQ) Builder.defineMacro("__AVX512DQ__"); if (HasAVX512BITALG) @@ -878,8 +888,6 @@ void X86TargetInfo::getTargetDefines(const LangOptions &Opts, Builder.defineMacro("__SM4__"); if (HasPREFETCHI) Builder.defineMacro("__PREFETCHI__"); - if (HasPREFETCHWT1) - Builder.defineMacro("__PREFETCHWT1__"); if (HasCLZERO) Builder.defineMacro("__CLZERO__"); if (HasKL) @@ -952,8 +960,17 @@ void X86TargetInfo::getTargetDefines(const LangOptions &Opts, Builder.defineMacro("__NDD__"); if (HasCCMP) Builder.defineMacro("__CCMP__"); + if (HasNF) + Builder.defineMacro("__NF__"); if (HasCF) Builder.defineMacro("__CF__"); + if (HasZU) + Builder.defineMacro("__ZU__"); + if (HasEGPR && HasPush2Pop2 && HasPPX && HasNDD && HasCCMP && HasNF && + HasCF && HasZU) + Builder.defineMacro("__APX_F__"); + if (HasEGPR && HasInlineAsmUseGPR32) + Builder.defineMacro("__APX_INLINE_ASM_USE_GPR32__"); // Each case falls through to the previous one here. switch (SSELevel) { @@ -1012,18 +1029,8 @@ void X86TargetInfo::getTargetDefines(const LangOptions &Opts, } // Each case falls through to the previous one here. - switch (MMX3DNowLevel) { - case AMD3DNowAthlon: - Builder.defineMacro("__3dNOW_A__"); - [[fallthrough]]; - case AMD3DNow: - Builder.defineMacro("__3dNOW__"); - [[fallthrough]]; - case MMX: + if (HasMMX) { Builder.defineMacro("__MMX__"); - [[fallthrough]]; - case NoMMX3DNow: - break; } if (CPU >= CK_i486 || CPU == CK_None) { @@ -1042,8 +1049,6 @@ void X86TargetInfo::getTargetDefines(const LangOptions &Opts, bool X86TargetInfo::isValidFeatureName(StringRef Name) const { return llvm::StringSwitch<bool>(Name) - .Case("3dnow", true) - .Case("3dnowa", true) .Case("adx", true) .Case("aes", true) .Case("amx-bf16", true) @@ -1060,9 +1065,7 @@ bool X86TargetInfo::isValidFeatureName(StringRef Name) const { .Case("avx512vpopcntdq", true) .Case("avx512vnni", true) .Case("avx512bf16", true) - .Case("avx512er", true) .Case("avx512fp16", true) - .Case("avx512pf", true) .Case("avx512dq", true) .Case("avx512bitalg", true) .Case("avx512bw", true) @@ -1110,7 +1113,6 @@ bool X86TargetInfo::isValidFeatureName(StringRef Name) const { .Case("pku", true) .Case("popcnt", true) .Case("prefetchi", true) - .Case("prefetchwt1", true) .Case("prfchw", true) .Case("ptwrite", true) .Case("raoint", true) @@ -1154,7 +1156,9 @@ bool X86TargetInfo::isValidFeatureName(StringRef Name) const { .Case("ppx", true) .Case("ndd", true) .Case("ccmp", true) + .Case("nf", true) .Case("cf", true) + .Case("zu", true) .Default(false); } @@ -1176,9 +1180,7 @@ bool X86TargetInfo::hasFeature(StringRef Feature) const { .Case("avx512vpopcntdq", HasAVX512VPOPCNTDQ) .Case("avx512vnni", HasAVX512VNNI) .Case("avx512bf16", HasAVX512BF16) - .Case("avx512er", HasAVX512ER) .Case("avx512fp16", HasAVX512FP16) - .Case("avx512pf", HasAVX512PF) .Case("avx512dq", HasAVX512DQ) .Case("avx512bitalg", HasAVX512BITALG) .Case("avx512bw", HasAVX512BW) @@ -1216,9 +1218,7 @@ bool X86TargetInfo::hasFeature(StringRef Feature) const { .Case("widekl", HasWIDEKL) .Case("lwp", HasLWP) .Case("lzcnt", HasLZCNT) - .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow) - .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon) - .Case("mmx", MMX3DNowLevel >= MMX) + .Case("mmx", HasMMX) .Case("movbe", HasMOVBE) .Case("movdiri", HasMOVDIRI) .Case("movdir64b", HasMOVDIR64B) @@ -1228,7 +1228,6 @@ bool X86TargetInfo::hasFeature(StringRef Feature) const { .Case("pku", HasPKU) .Case("popcnt", HasPOPCNT) .Case("prefetchi", HasPREFETCHI) - .Case("prefetchwt1", HasPREFETCHWT1) .Case("prfchw", HasPRFCHW) .Case("ptwrite", HasPTWRITE) .Case("raoint", HasRAOINT) @@ -1276,7 +1275,10 @@ bool X86TargetInfo::hasFeature(StringRef Feature) const { .Case("ppx", HasPPX) .Case("ndd", HasNDD) .Case("ccmp", HasCCMP) + .Case("nf", HasNF) .Case("cf", HasCF) + .Case("zu", HasZU) + .Case("branch-hint", HasBranchHint) .Default(false); } @@ -1473,6 +1475,18 @@ bool X86TargetInfo::validateAsmConstraint( case 'C': // SSE floating point constant. case 'G': // x87 floating point constant. return true; + case 'j': + Name++; + switch (*Name) { + default: + return false; + case 'r': + Info.setAllowsRegister(); + return true; + case 'R': + Info.setAllowsRegister(); + return true; + } case '@': // CC condition changes. if (auto Len = matchAsmCCConstraint(Name)) { @@ -1602,6 +1616,7 @@ std::optional<unsigned> X86TargetInfo::getCPUCacheLineSize() const { case CK_ZNVER2: case CK_ZNVER3: case CK_ZNVER4: + case CK_ZNVER5: // Deprecated case CK_x86_64: case CK_x86_64_v2: @@ -1745,6 +1760,21 @@ std::string X86TargetInfo::convertConstraint(const char *&Constraint) const { return std::string("^") + std::string(Constraint++, 2); } [[fallthrough]]; + case 'j': + switch (Constraint[1]) { + default: + // Break from inner switch and fall through (copy single char), + // continue parsing after copying the current constraint into + // the return string. + break; + case 'r': + case 'R': + // "^" hints llvm that this is a 2 letter constraint. + // "Constraint++" is used to promote the string iterator + // to the next constraint. + return std::string("^") + std::string(Constraint++, 2); + } + [[fallthrough]]; default: return std::string(1, *Constraint); } diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/X86.h b/contrib/llvm-project/clang/lib/Basic/Targets/X86.h index 0ab1c10833db..ba34ab2c7f33 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/X86.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/X86.h @@ -67,12 +67,7 @@ class LLVM_LIBRARY_VISIBILITY X86TargetInfo : public TargetInfo { AVX2, AVX512F } SSELevel = NoSSE; - enum MMX3DNowEnum { - NoMMX3DNow, - MMX, - AMD3DNow, - AMD3DNowAthlon - } MMX3DNowLevel = NoMMX3DNow; + bool HasMMX = false; enum XOPEnum { NoXOP, SSE4A, FMA4, XOP } XOPLevel = NoXOP; enum AddrSpace { ptr32_sptr = 270, ptr32_uptr = 271, ptr64 = 272 }; @@ -103,8 +98,6 @@ class LLVM_LIBRARY_VISIBILITY X86TargetInfo : public TargetInfo { bool HasAVX512VNNI = false; bool HasAVX512FP16 = false; bool HasAVX512BF16 = false; - bool HasAVX512ER = false; - bool HasAVX512PF = false; bool HasAVX512DQ = false; bool HasAVX512BITALG = false; bool HasAVX512BW = false; @@ -136,7 +129,6 @@ class LLVM_LIBRARY_VISIBILITY X86TargetInfo : public TargetInfo { bool HasCLWB = false; bool HasMOVBE = false; bool HasPREFETCHI = false; - bool HasPREFETCHWT1 = false; bool HasRDPID = false; bool HasRDPRU = false; bool HasRetpolineExternalThunk = false; @@ -173,7 +165,11 @@ class LLVM_LIBRARY_VISIBILITY X86TargetInfo : public TargetInfo { bool HasPPX = false; bool HasNDD = false; bool HasCCMP = false; + bool HasNF = false; bool HasCF = false; + bool HasZU = false; + bool HasInlineAsmUseGPR32 = false; + bool HasBranchHint = false; protected: llvm::X86::CPUKind CPU = llvm::X86::CK_None; @@ -188,6 +184,7 @@ public: LongDoubleFormat = &llvm::APFloat::x87DoubleExtended(); AddrSpaceMap = &X86AddrSpaceMap; HasStrictFP = true; + HasUnalignedAccess = true; bool IsWinCOFF = getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF(); @@ -217,9 +214,13 @@ public: ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override; bool isSPRegName(StringRef RegName) const override { - return RegName.equals("esp") || RegName.equals("rsp"); + return RegName == "esp" || RegName == "rsp"; } + bool supportsCpuSupports() const override { return true; } + bool supportsCpuIs() const override { return true; } + bool supportsCpuInit() const override { return true; } + bool validateCpuSupports(StringRef FeatureStr) const override; bool validateCpuIs(StringRef FeatureStr) const override; @@ -241,7 +242,7 @@ public: bool &HasSizeMismatch) const override { // esp and ebp are the only 32-bit registers the x86 backend can currently // handle. - if (RegName.equals("esp") || RegName.equals("ebp")) { + if (RegName == "esp" || RegName == "ebp") { // Check that the register size is 32-bit. HasSizeMismatch = RegSize != 32; return true; @@ -342,8 +343,7 @@ public: return "avx512"; if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX) return "avx"; - if (getTriple().getArch() == llvm::Triple::x86 && - MMX3DNowLevel == NoMMX3DNow) + if (getTriple().getArch() == llvm::Triple::x86 && !HasMMX) return "no-mmx"; return ""; } @@ -513,15 +513,6 @@ class LLVM_LIBRARY_VISIBILITY NetBSDI386TargetInfo public: NetBSDI386TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) : NetBSDTargetInfo<X86_32TargetInfo>(Triple, Opts) {} - - LangOptions::FPEvalMethodKind getFPEvalMethod() const override { - VersionTuple OsVersion = getTriple().getOSVersion(); - // New NetBSD uses the default rounding mode. - if (OsVersion >= VersionTuple(6, 99, 26) || OsVersion.getMajor() == 0) - return X86_32TargetInfo::getFPEvalMethod(); - // NetBSD before 6.99.26 defaults to "double" rounding. - return LangOptions::FPEvalMethodKind::FEM_Double; - } }; class LLVM_LIBRARY_VISIBILITY OpenBSDI386TargetInfo @@ -668,6 +659,7 @@ public: MCUX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) : X86_32TargetInfo(Triple, Opts) { LongDoubleWidth = 64; + DefaultAlignForAttributeAligned = 32; LongDoubleFormat = &llvm::APFloat::IEEEdouble(); resetDataLayout("e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:32-" "f64:32-f128:32-n8:16:32-a:0:32-S32"); @@ -772,6 +764,7 @@ public: case CC_Win64: case CC_PreserveMost: case CC_PreserveAll: + case CC_PreserveNone: case CC_X86RegCall: case CC_OpenCLKernel: return CCCR_OK; @@ -795,7 +788,7 @@ public: bool &HasSizeMismatch) const override { // rsp and rbp are the only 64-bit registers the x86 backend can currently // handle. - if (RegName.equals("rsp") || RegName.equals("rbp")) { + if (RegName == "rsp" || RegName == "rbp") { // Check that the register size is 64-bit. HasSizeMismatch = RegSize != 64; return true; @@ -849,6 +842,7 @@ public: case CC_IntelOclBicc: case CC_PreserveMost: case CC_PreserveAll: + case CC_PreserveNone: case CC_X86_64SysV: case CC_Swift: case CC_SwiftAsync: diff --git a/contrib/llvm-project/clang/lib/Basic/TypeTraits.cpp b/contrib/llvm-project/clang/lib/Basic/TypeTraits.cpp index 4dbf678dc395..8d6794223cca 100644 --- a/contrib/llvm-project/clang/lib/Basic/TypeTraits.cpp +++ b/contrib/llvm-project/clang/lib/Basic/TypeTraits.cpp @@ -13,6 +13,7 @@ #include "clang/Basic/TypeTraits.h" #include "llvm/Support/ErrorHandling.h" #include <cassert> +#include <cstring> using namespace clang; static constexpr const char *TypeTraitNames[] = { @@ -81,6 +82,15 @@ const char *clang::getTraitName(UnaryExprOrTypeTrait T) { const char *clang::getTraitSpelling(TypeTrait T) { assert(T <= TT_Last && "invalid enum value!"); + if (T == BTT_IsDeducible) { + // The __is_deducible is an internal-only type trait. To hide it from + // external users, we define it with an empty spelling name, preventing the + // clang parser from recognizing its token kind. + // However, other components such as the AST dump still require the real + // type trait name. Therefore, we return the real name when needed. + assert(std::strlen(TypeTraitSpellings[T]) == 0); + return "__is_deducible"; + } return TypeTraitSpellings[T]; } |