michaelplatings updated this revision to Diff 494406.
michaelplatings added a comment.
Move the regular expression flag matching functionality into MutlilibSet. This
(a) simplifies the code for loading from multilib.yaml; and (b) makes the flag
matching functionality easier to access.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D142932/new/
https://reviews.llvm.org/D142932
Files:
clang/include/clang/Driver/Multilib.h
clang/lib/Driver/Multilib.cpp
clang/unittests/Driver/MultilibTest.cpp
Index: clang/unittests/Driver/MultilibTest.cpp
===================================================================
--- clang/unittests/Driver/MultilibTest.cpp
+++ clang/unittests/Driver/MultilibTest.cpp
@@ -187,3 +187,340 @@
EXPECT_EQ("/a", Selection[0].gccSuffix());
EXPECT_EQ("/b", Selection[1].gccSuffix());
}
+
+static void diagnosticCallback(const llvm::SMDiagnostic &D, void *Out) {
+ *reinterpret_cast<std::string *>(Out) = D.getMessage();
+}
+
+static bool parse(MultilibSet &MS, std::string &Diagnostic, const char *Data) {
+ return MS.parse(llvm::MemoryBufferRef(Data, "TEST"), diagnosticCallback,
+ &Diagnostic);
+}
+
+static bool parse(MultilibSet &MS, const char *Data) {
+ return MS.parse(llvm::MemoryBufferRef(Data, "TEST"));
+}
+
+TEST(MultilibTest, ParseInvalid) {
+ std::string Diagnostic;
+
+ MultilibSet MS;
+ EXPECT_FALSE(parse(MS, Diagnostic, R"(
+variants:
+- dir: /abc
+ flags: []
+ printArgs: []
+)"));
+ EXPECT_TRUE(StringRef(Diagnostic).contains("paths must be relative"))
+ << Diagnostic;
+
+ EXPECT_FALSE(parse(MS, Diagnostic, R"(
+variants:
+- flags: []
+ printArgs: []
+)"));
+ EXPECT_TRUE(StringRef(Diagnostic).contains("missing required key 'dir'"))
+ << Diagnostic;
+
+ EXPECT_FALSE(parse(MS, Diagnostic, R"(
+variants:
+- dir: .
+ printArgs: []
+)"));
+ EXPECT_TRUE(StringRef(Diagnostic).contains("missing required key 'flags'"))
+ << Diagnostic;
+
+ EXPECT_FALSE(parse(MS, Diagnostic, R"(
+variants:
+- dir: .
+ flags: []
+)"));
+ EXPECT_TRUE(
+ StringRef(Diagnostic).contains("missing required key 'printArgs'"))
+ << Diagnostic;
+
+ EXPECT_FALSE(parse(MS, Diagnostic, R"(
+flagMap:
+- regex: abc
+)"));
+ EXPECT_TRUE(
+ StringRef(Diagnostic)
+ .contains("value required for 'matchFlags' or 'noMatchFlags'"))
+ << Diagnostic;
+
+ EXPECT_FALSE(parse(MS, Diagnostic, R"(
+flagMap:
+- dir: .
+ regex: '('
+ printArgs: []
+
+)"));
+ EXPECT_TRUE(StringRef(Diagnostic).contains("parentheses not balanced"))
+ << Diagnostic;
+}
+
+TEST(MultilibTest, Parse) {
+ MultilibSet MS;
+ EXPECT_TRUE(parse(MS, R"(
+variants:
+- dir: .
+ flags: []
+ printArgs: []
+)"));
+ EXPECT_EQ(1U, MS.size());
+ EXPECT_EQ("", MS.begin()->gccSuffix());
+
+ EXPECT_TRUE(parse(MS, R"(
+variants:
+- dir: abc
+ flags: []
+ printArgs: []
+)"));
+ EXPECT_EQ(1U, MS.size());
+ EXPECT_EQ("/abc", MS.begin()->gccSuffix());
+
+ EXPECT_TRUE(parse(MS, R"(
+variants:
+- dir: pqr
+ flags: []
+ printArgs: [-mfloat-abi=soft]
+)"));
+ EXPECT_EQ(1U, MS.size());
+ EXPECT_EQ("/pqr", MS.begin()->gccSuffix());
+ EXPECT_EQ(std::vector<std::string>({"-mfloat-abi=soft"}),
+ MS.begin()->getPrintArgs());
+
+ EXPECT_TRUE(parse(MS, R"(
+variants:
+- dir: pqr
+ flags: []
+ printArgs: [-mfloat-abi=soft, -fno-exceptions]
+)"));
+ EXPECT_EQ(1U, MS.size());
+ EXPECT_EQ(std::vector<std::string>({"-mfloat-abi=soft", "-fno-exceptions"}),
+ MS.begin()->getPrintArgs());
+
+ EXPECT_TRUE(parse(MS, R"(
+variants:
+- dir: a
+ flags: []
+ printArgs: []
+- dir: b
+ flags: []
+ printArgs: []
+)"));
+ EXPECT_EQ(2U, MS.size());
+}
+
+TEST(MultilibTest, SelectSoft) {
+ MultilibSet MS;
+ Multilib Selected;
+ ASSERT_TRUE(parse(MS, R"(
+variants:
+- dir: s
+ flags: [softabi]
+ printArgs: []
+flagMap:
+- regex: mfloat-abi=soft
+ matchFlags: [softabi]
+- regex: mfloat-abi=softfp
+ matchFlags: [softabi]
+)"));
+ EXPECT_TRUE(MS.select({"mfloat-abi=soft"}, Selected));
+ EXPECT_TRUE(MS.select({"mfloat-abi=softfp"}, Selected));
+ EXPECT_FALSE(MS.select({"mfloat-abi=hard"}, Selected));
+}
+
+TEST(MultilibTest, SelectSoftFP) {
+ MultilibSet MS;
+ Multilib Selected;
+ ASSERT_TRUE(parse(MS, R"(
+variants:
+- dir: f
+ flags: [mfloat-abi=softfp]
+ printArgs: []
+)"));
+ EXPECT_FALSE(MS.select({"mfloat-abi=soft"}, Selected));
+ EXPECT_TRUE(MS.select({"mfloat-abi=softfp"}, Selected));
+ EXPECT_FALSE(MS.select({"mfloat-abi=hard"}, Selected));
+}
+
+TEST(MultilibTest, SelectHard) {
+ // If hard float is all that's available then select that only if compiling
+ // with hard float.
+ MultilibSet MS;
+ Multilib Selected;
+ ASSERT_TRUE(parse(MS, R"(
+variants:
+- dir: h
+ flags: [mfloat-abi=hard]
+ printArgs: []
+)"));
+ EXPECT_FALSE(MS.select({"mfloat-abi=soft"}, Selected));
+ EXPECT_FALSE(MS.select({"mfloat-abi=softfp"}, Selected));
+ EXPECT_TRUE(MS.select({"mfloat-abi=hard"}, Selected));
+}
+
+TEST(MultilibTest, SelectFloatABI) {
+ MultilibSet MS;
+ Multilib Selected;
+ ASSERT_TRUE(parse(MS, R"(
+variants:
+- dir: s
+ flags: [softabi]
+ printArgs: []
+- dir: f
+ flags: [softabi, hasfp]
+ printArgs: []
+- dir: h
+ flags: [hardabi, hasfp]
+ printArgs: []
+flagMap:
+- regex: mfloat-abi=(soft|softfp)
+ matchFlags: [softabi]
+- regex: mfloat-abi=hard
+ matchFlags: [hardabi]
+- regex: mfloat-abi=soft
+ noMatchFlags: [hasfp]
+)"));
+ MS.select({"mfloat-abi=soft"}, Selected);
+ EXPECT_EQ("/s", Selected.gccSuffix());
+ MS.select({"mfloat-abi=softfp"}, Selected);
+ EXPECT_EQ("/f", Selected.gccSuffix());
+ MS.select({"mfloat-abi=hard"}, Selected);
+ EXPECT_EQ("/h", Selected.gccSuffix());
+}
+
+TEST(MultilibTest, SelectFloatABIReversed) {
+ // If soft is specified after softfp then softfp will never be
+ // selected because soft is compatible with softfp and last wins.
+ MultilibSet MS;
+ Multilib Selected;
+ ASSERT_TRUE(parse(MS, R"(
+variants:
+- dir: h
+ flags: [hardabi, hasfp]
+ printArgs: []
+- dir: f
+ flags: [softabi, hasfp]
+ printArgs: []
+- dir: s
+ flags: [softabi]
+ printArgs: []
+flagMap:
+- regex: mfloat-abi=(soft|softfp)
+ matchFlags: [softabi]
+- regex: mfloat-abi=hard
+ matchFlags: [hardabi]
+- regex: mfloat-abi=soft
+ noMatchFlags: [hasfp]
+)"));
+ MS.select({"mfloat-abi=soft"}, Selected);
+ EXPECT_EQ("/s", Selected.gccSuffix());
+ MS.select({"mfloat-abi=softfp"}, Selected);
+ EXPECT_EQ("/s", Selected.gccSuffix());
+ MS.select({"mfloat-abi=hard"}, Selected);
+ EXPECT_EQ("/h", Selected.gccSuffix());
+}
+
+TEST(MultilibTest, SelectMClass) {
+ const char *MultilibSpec = R"(
+variants:
+- dir: thumb/v6-m/nofp
+ flags: [target=thumbv6m-none-eabi]
+ printArgs: [--target=thumbv6m-none-eabi, -mfloat-abi=soft]
+
+- dir: thumb/v7-m/nofp
+ flags: [target=thumbv7m-none-eabi]
+ printArgs: [--target=thumbv7m-none-eabi, -mfloat-abi=soft]
+
+- dir: thumb/v7e-m/nofp
+ flags: [target=thumbv7em-none-eabi]
+ printArgs: [--target=thumbv7em-none-eabi, -mfloat-abi=soft, -mfpu=none]
+
+- dir: thumb/v8-m.main/nofp
+ flags: [target=thumbv8m.main-none-eabi]
+ printArgs: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv8m.main+nofp]
+
+- dir: thumb/v8.1-m.main/nofp/nomve
+ flags: [target=thumbv8.1m.main-none-eabi]
+ printArgs: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv8.1m.main+nofp+nomve]
+
+- dir: thumb/v7e-m/fpv4_sp_d16
+ flags: [target=thumbv7em-none-eabihf, mfpu=fpv4-sp-d16]
+ printArgs: [--target=thumbv7em-none-eabihf, -mfpu=fpv4-sp-d16]
+
+- dir: thumb/v7e-m/fpv5_d16
+ flags: [target=thumbv7em-none-eabihf, mfpu=fpv5-d16]
+ printArgs: [--target=thumbv7em-none-eabihf, -mfpu=fpv5-d16]
+
+- dir: thumb/v8-m.main/fp
+ flags: [target=thumbv8m.main-none-eabihf]
+ printArgs: [--target=thumbv8m.main-none-eabihf]
+
+- dir: thumb/v8.1-m.main/fp
+ flags: [target=thumbv8.1m.main-none-eabihf]
+ printArgs: [--target=thumbv8.1m.main-none-eabihf]
+
+- dir: thumb/v8.1-m.main/nofp/mve
+ flags: [target=thumbv8.1m.main-none-eabihf, march=+mve]
+ printArgs: [--target=arm-none-eabihf, -march=armv8.1m.main+nofp+mve]
+
+flagMap:
+- regex: target=thumbv8(\.[0-9]+)?m\.base-none-eabi
+ matchFlags: [target=thumbv6m-none-eabi]
+- regex: thumbv8\.[1-9]m\.main-none-eabi
+ matchFlags: [target=thumbv8.1m.main-none-eabi]
+- regex: thumbv8\.[1-9]m\.main-none-eabihf
+ matchFlags: [target=thumbv8.1m.main-none-eabihf]
+)";
+
+ MultilibSet MS;
+ Multilib Selected;
+ ASSERT_TRUE(parse(MS, MultilibSpec));
+
+ EXPECT_TRUE(
+ MS.select({"target=thumbv6m-none-eabi", "mfloat-abi=soft"}, Selected));
+ EXPECT_EQ("/thumb/v6-m/nofp", Selected.gccSuffix());
+
+ EXPECT_TRUE(
+ MS.select({"target=thumbv7m-none-eabi", "mfloat-abi=soft"}, Selected));
+ EXPECT_EQ("/thumb/v7-m/nofp", Selected.gccSuffix());
+
+ EXPECT_TRUE(
+ MS.select({"target=thumbv7em-none-eabi", "mfloat-abi=soft", "mfpu=none"},
+ Selected));
+ EXPECT_EQ("/thumb/v7e-m/nofp", Selected.gccSuffix());
+
+ EXPECT_TRUE(MS.select({"target=thumbv8m.main-none-eabi", "mfloat-abi=soft"},
+ Selected));
+ EXPECT_EQ("/thumb/v8-m.main/nofp", Selected.gccSuffix());
+
+ EXPECT_TRUE(MS.select(
+ {"target=thumbv8.1m.main-none-eabi", "mfloat-abi=soft", "mfpu=none"},
+ Selected));
+ EXPECT_EQ("/thumb/v8.1-m.main/nofp/nomve", Selected.gccSuffix());
+
+ EXPECT_TRUE(MS.select(
+ {"target=thumbv7em-none-eabihf", "mfloat-abi=hard", "mfpu=fpv4-sp-d16"},
+ Selected));
+ EXPECT_EQ("/thumb/v7e-m/fpv4_sp_d16", Selected.gccSuffix());
+
+ EXPECT_TRUE(MS.select(
+ {"target=thumbv7em-none-eabihf", "mfloat-abi=hard", "mfpu=fpv5-d16"},
+ Selected));
+ EXPECT_EQ("/thumb/v7e-m/fpv5_d16", Selected.gccSuffix());
+
+ EXPECT_TRUE(MS.select({"target=thumbv8m.main-none-eabihf", "mfloat-abi=hard"},
+ Selected));
+ EXPECT_EQ("/thumb/v8-m.main/fp", Selected.gccSuffix());
+
+ EXPECT_TRUE(MS.select(
+ {"target=thumbv8.1m.main-none-eabihf", "mfloat-abi=hard"}, Selected));
+ EXPECT_EQ("/thumb/v8.1-m.main/fp", Selected.gccSuffix());
+
+ EXPECT_TRUE(MS.select({"target=thumbv8.1m.main-none-eabihf",
+ "mfloat-abi=hard", "mfpu=none", "march=+mve"},
+ Selected));
+ EXPECT_EQ("/thumb/v8.1-m.main/nofp/mve", Selected.gccSuffix());
+}
Index: clang/lib/Driver/Multilib.cpp
===================================================================
--- clang/lib/Driver/Multilib.cpp
+++ clang/lib/Driver/Multilib.cpp
@@ -16,10 +16,10 @@
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Regex.h"
+#include "llvm/Support/YAMLParser.h"
+#include "llvm/Support/YAMLTraits.h"
#include "llvm/Support/raw_ostream.h"
-#include <algorithm>
#include <cassert>
-#include <string>
using namespace clang;
using namespace driver;
@@ -84,10 +84,11 @@
std::vector<Multilib>
MultilibSet::select(const Multilib::flags_list &Flags) const {
+ Multilib::flags_list AllFlags(expandFlags(Flags));
multilib_list Result;
llvm::copy_if(Multilibs, std::back_inserter(Result),
- [&Flags](const Multilib &M) {
- return std::includes(Flags.begin(), Flags.end(),
+ [&AllFlags](const Multilib &M) {
+ return std::includes(AllFlags.begin(), AllFlags.end(),
M.flags().begin(), M.flags().end());
});
return Result;
@@ -103,6 +104,108 @@
return true;
}
+Multilib::flags_list
+MultilibSet::expandFlags(const Multilib::flags_list &InFlags) const {
+ Multilib::flags_list Result(InFlags);
+ for (const FlagMatcher &M : FlagMatchers) {
+ std::string RegexString(M.Regex);
+
+ // Make the regular expression match the whole string.
+ if (!StringRef(M.Regex).starts_with("^")) {
+ RegexString.insert(RegexString.begin(), '^');
+ }
+ if (!StringRef(M.Regex).ends_with("$")) {
+ RegexString.push_back('$');
+ }
+
+ const llvm::Regex Regex(RegexString);
+ assert(Regex.isValid());
+ if (llvm::find_if(InFlags, [&Regex](StringRef F) {
+ return Regex.match(F);
+ }) != InFlags.end()) {
+ Result.insert(M.MatchFlags.begin(), M.MatchFlags.end());
+ } else {
+ Result.insert(M.NoMatchFlags.begin(), M.NoMatchFlags.end());
+ }
+ }
+ return Result;
+}
+
+struct MultilibSerialization {
+ std::string Dir;
+ std::vector<std::string> Flags, PrintArgs;
+};
+
+struct MultilibSetSerialization {
+ std::vector<MultilibSerialization> Multilibs;
+ std::vector<MultilibSet::FlagMatcher> FlagMatchers;
+};
+
+template <> struct llvm::yaml::MappingTraits<MultilibSerialization> {
+ static void mapping(llvm::yaml::IO &io, MultilibSerialization &V) {
+ io.mapRequired("dir", V.Dir);
+ io.mapRequired("flags", V.Flags);
+ io.mapRequired("printArgs", V.PrintArgs);
+ }
+ static std::string validate(IO &io, MultilibSerialization &V) {
+ if (StringRef(V.Dir).starts_with("/"))
+ return "paths must be relative. \"" + V.Dir + "\" starts with \"/\"\n";
+ return std::string{};
+ }
+};
+
+template <> struct llvm::yaml::MappingTraits<MultilibSet::FlagMatcher> {
+ static void mapping(llvm::yaml::IO &io, MultilibSet::FlagMatcher &M) {
+ io.mapRequired("regex", M.Regex);
+ io.mapOptional("matchFlags", M.MatchFlags);
+ io.mapOptional("noMatchFlags", M.NoMatchFlags);
+ }
+ static std::string validate(IO &io, MultilibSet::FlagMatcher &M) {
+ llvm::Regex Regex(M.Regex);
+ std::string RegexError;
+ if (!Regex.isValid(RegexError)) {
+ return RegexError;
+ }
+ if (M.MatchFlags.empty() && M.NoMatchFlags.empty())
+ return "value required for 'matchFlags' or 'noMatchFlags'";
+ return std::string{};
+ }
+};
+
+template <> struct llvm::yaml::MappingTraits<MultilibSetSerialization> {
+ static void mapping(llvm::yaml::IO &io, MultilibSetSerialization &M) {
+ io.mapOptional("variants", M.Multilibs);
+ io.mapOptional("flagMap", M.FlagMatchers);
+ }
+};
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(MultilibSerialization)
+LLVM_YAML_IS_SEQUENCE_VECTOR(MultilibSet::FlagMatcher)
+
+bool MultilibSet::parse(llvm::MemoryBufferRef Input,
+ llvm::SourceMgr::DiagHandlerTy DiagHandler,
+ void *DiagHandlerCtxt) {
+ MultilibSetSerialization MS;
+ llvm::yaml::Input YamlInput(Input, nullptr, DiagHandler, DiagHandlerCtxt);
+ YamlInput >> MS;
+ if (YamlInput.error())
+ return false;
+
+ Multilibs.clear();
+ Multilibs.reserve(MS.Multilibs.size());
+ for (const auto &M : MS.Multilibs) {
+ std::string Dir;
+ if (M.Dir != ".") {
+ Dir = "/" + M.Dir;
+ }
+ Multilibs.emplace_back(Dir, Dir, Dir,
+ Multilib::flags_list(M.Flags.begin(), M.Flags.end()),
+ M.PrintArgs);
+ }
+ FlagMatchers = std::move(MS.FlagMatchers);
+ return true;
+}
+
LLVM_DUMP_METHOD void MultilibSet::dump() const {
print(llvm::errs());
}
Index: clang/include/clang/Driver/Multilib.h
===================================================================
--- clang/include/clang/Driver/Multilib.h
+++ clang/include/clang/Driver/Multilib.h
@@ -14,6 +14,7 @@
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Compiler.h"
+#include "llvm/Support/SourceMgr.h"
#include <cassert>
#include <functional>
#include <set>
@@ -82,8 +83,19 @@
std::function<std::vector<std::string>(const Multilib &M)>;
using FilterCallback = llvm::function_ref<bool(const Multilib &)>;
+ /// Uses regular expressions to simplify flags used for multilib selection.
+ /// For example, we may wish to simplify armv8, armv8.1, armv8.2 etc. to
+ /// simply "v8". It's also possible to negate matches. For example, it may be
+ /// appropriate to infer that if mfpu=none *doesn't* match then an FPU is
+ /// available. NoMatchFlags can be used for this purpose.
+ struct FlagMatcher {
+ std::string Regex;
+ std::vector<std::string> MatchFlags, NoMatchFlags;
+ };
+
private:
multilib_list Multilibs;
+ std::vector<FlagMatcher> FlagMatchers;
IncludeDirsFunc IncludeCallback;
IncludeDirsFunc FilePathsCallback;
@@ -110,6 +122,15 @@
unsigned size() const { return Multilibs.size(); }
+ /// Get the given flags plus flags found by matching them against the
+ /// FlagMatchers and choosing the MatchFlags or NoMatchFlags of each
+ /// accordingly. The select method calls this method so in most cases it's not
+ /// necessary to call it directly.
+ Multilib::flags_list expandFlags(const Multilib::flags_list &) const;
+
+ bool parse(llvm::MemoryBufferRef, llvm::SourceMgr::DiagHandlerTy = nullptr,
+ void *DiagHandlerCtxt = nullptr);
+
LLVM_DUMP_METHOD void dump() const;
void print(raw_ostream &OS) const;
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
