Home | History | Annotate | Download | only in Driver 
      1 //===--- Multilib.cpp - Multilib Implementation ---------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 #include "clang/Driver/Multilib.h"
     11 #include "Tools.h"
     12 #include "clang/Driver/Options.h"
     13 #include "llvm/ADT/StringMap.h"
     14 #include "llvm/ADT/StringRef.h"
     15 #include "llvm/ADT/StringSet.h"
     16 #include "llvm/ADT/Triple.h"
     17 #include "llvm/Option/Arg.h"
     18 #include "llvm/Option/ArgList.h"
     19 #include "llvm/Option/OptTable.h"
     20 #include "llvm/Option/Option.h"
     21 #include "llvm/Support/MemoryBuffer.h"
     22 #include "llvm/Support/Path.h"
     23 #include "llvm/Support/Regex.h"
     24 #include "llvm/Support/YAMLParser.h"
     25 #include "llvm/Support/YAMLTraits.h"
     26 #include "llvm/Support/raw_ostream.h"
     27 #include <algorithm>
     28 
     29 using namespace clang::driver;
     30 using namespace clang;
     31 using namespace llvm::opt;
     32 using namespace llvm::sys;
     33 
     34 /// normalize Segment to "/foo/bar" or "".
     35 static void normalizePathSegment(std::string &Segment) {
     36   StringRef seg = Segment;
     37 
     38   // Prune trailing "/" or "./"
     39   while (1) {
     40     StringRef last = *--path::end(seg);
     41     if (last != ".")
     42       break;
     43     seg = path::parent_path(seg);
     44   }
     45 
     46   if (seg.empty() || seg == "/") {
     47     Segment = "";
     48     return;
     49   }
     50 
     51   // Add leading '/'
     52   if (seg.front() != '/') {
     53     Segment = "/" + seg.str();
     54   } else {
     55     Segment = seg;
     56   }
     57 }
     58 
     59 Multilib::Multilib(StringRef GCCSuffix, StringRef OSSuffix,
     60                    StringRef IncludeSuffix)
     61     : GCCSuffix(GCCSuffix), OSSuffix(OSSuffix), IncludeSuffix(IncludeSuffix) {
     62   normalizePathSegment(this->GCCSuffix);
     63   normalizePathSegment(this->OSSuffix);
     64   normalizePathSegment(this->IncludeSuffix);
     65 }
     66 
     67 Multilib &Multilib::gccSuffix(StringRef S) {
     68   GCCSuffix = S;
     69   normalizePathSegment(GCCSuffix);
     70   return *this;
     71 }
     72 
     73 Multilib &Multilib::osSuffix(StringRef S) {
     74   OSSuffix = S;
     75   normalizePathSegment(OSSuffix);
     76   return *this;
     77 }
     78 
     79 Multilib &Multilib::includeSuffix(StringRef S) {
     80   IncludeSuffix = S;
     81   normalizePathSegment(IncludeSuffix);
     82   return *this;
     83 }
     84 
     85 void Multilib::print(raw_ostream &OS) const {
     86   assert(GCCSuffix.empty() || (StringRef(GCCSuffix).front() == '/'));
     87   if (GCCSuffix.empty())
     88     OS << ".";
     89   else {
     90     OS << StringRef(GCCSuffix).drop_front();
     91   }
     92   OS << ";";
     93   for (StringRef Flag : Flags) {
     94     if (Flag.front() == '+')
     95       OS << "@" << Flag.substr(1);
     96   }
     97 }
     98 
     99 bool Multilib::isValid() const {
    100   llvm::StringMap<int> FlagSet;
    101   for (unsigned I = 0, N = Flags.size(); I != N; ++I) {
    102     StringRef Flag(Flags[I]);
    103     llvm::StringMap<int>::iterator SI = FlagSet.find(Flag.substr(1));
    104 
    105     assert(StringRef(Flag).front() == '+' || StringRef(Flag).front() == '-');
    106 
    107     if (SI == FlagSet.end())
    108       FlagSet[Flag.substr(1)] = I;
    109     else if (Flags[I] != Flags[SI->getValue()])
    110       return false;
    111   }
    112   return true;
    113 }
    114 
    115 bool Multilib::operator==(const Multilib &Other) const {
    116   // Check whether the flags sets match
    117   // allowing for the match to be order invariant
    118   llvm::StringSet<> MyFlags;
    119   for (const auto &Flag : Flags)
    120     MyFlags.insert(Flag);
    121 
    122   for (const auto &Flag : Other.Flags)
    123     if (MyFlags.find(Flag) == MyFlags.end())
    124       return false;
    125 
    126   if (osSuffix() != Other.osSuffix())
    127     return false;
    128 
    129   if (gccSuffix() != Other.gccSuffix())
    130     return false;
    131 
    132   if (includeSuffix() != Other.includeSuffix())
    133     return false;
    134 
    135   return true;
    136 }
    137 
    138 raw_ostream &clang::driver::operator<<(raw_ostream &OS, const Multilib &M) {
    139   M.print(OS);
    140   return OS;
    141 }
    142 
    143 MultilibSet &MultilibSet::Maybe(const Multilib &M) {
    144   Multilib Opposite;
    145   // Negate any '+' flags
    146   for (StringRef Flag : M.flags()) {
    147     if (Flag.front() == '+')
    148       Opposite.flags().push_back(("-" + Flag.substr(1)).str());
    149   }
    150   return Either(M, Opposite);
    151 }
    152 
    153 MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2) {
    154   std::vector<Multilib> Ms;
    155   Ms.push_back(M1);
    156   Ms.push_back(M2);
    157   return Either(Ms);
    158 }
    159 
    160 MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2,
    161                                  const Multilib &M3) {
    162   std::vector<Multilib> Ms;
    163   Ms.push_back(M1);
    164   Ms.push_back(M2);
    165   Ms.push_back(M3);
    166   return Either(Ms);
    167 }
    168 
    169 MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2,
    170                                  const Multilib &M3, const Multilib &M4) {
    171   std::vector<Multilib> Ms;
    172   Ms.push_back(M1);
    173   Ms.push_back(M2);
    174   Ms.push_back(M3);
    175   Ms.push_back(M4);
    176   return Either(Ms);
    177 }
    178 
    179 MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2,
    180                                  const Multilib &M3, const Multilib &M4,
    181                                  const Multilib &M5) {
    182   std::vector<Multilib> Ms;
    183   Ms.push_back(M1);
    184   Ms.push_back(M2);
    185   Ms.push_back(M3);
    186   Ms.push_back(M4);
    187   Ms.push_back(M5);
    188   return Either(Ms);
    189 }
    190 
    191 static Multilib compose(const Multilib &Base, const Multilib &New) {
    192   SmallString<128> GCCSuffix;
    193   llvm::sys::path::append(GCCSuffix, "/", Base.gccSuffix(), New.gccSuffix());
    194   SmallString<128> OSSuffix;
    195   llvm::sys::path::append(OSSuffix, "/", Base.osSuffix(), New.osSuffix());
    196   SmallString<128> IncludeSuffix;
    197   llvm::sys::path::append(IncludeSuffix, "/", Base.includeSuffix(),
    198                           New.includeSuffix());
    199 
    200   Multilib Composed(GCCSuffix.str(), OSSuffix.str(), IncludeSuffix.str());
    201 
    202   Multilib::flags_list &Flags = Composed.flags();
    203 
    204   Flags.insert(Flags.end(), Base.flags().begin(), Base.flags().end());
    205   Flags.insert(Flags.end(), New.flags().begin(), New.flags().end());
    206 
    207   return Composed;
    208 }
    209 
    210 MultilibSet &
    211 MultilibSet::Either(const std::vector<Multilib> &MultilibSegments) {
    212   multilib_list Composed;
    213 
    214   if (Multilibs.empty())
    215     Multilibs.insert(Multilibs.end(), MultilibSegments.begin(),
    216                      MultilibSegments.end());
    217   else {
    218     for (const Multilib &New : MultilibSegments) {
    219       for (const Multilib &Base : *this) {
    220         Multilib MO = compose(Base, New);
    221         if (MO.isValid())
    222           Composed.push_back(MO);
    223       }
    224     }
    225 
    226     Multilibs = Composed;
    227   }
    228 
    229   return *this;
    230 }
    231 
    232 MultilibSet &MultilibSet::FilterOut(const MultilibSet::FilterCallback &F) {
    233   filterInPlace(F, Multilibs);
    234   return *this;
    235 }
    236 
    237 MultilibSet &MultilibSet::FilterOut(std::string Regex) {
    238   class REFilter : public MultilibSet::FilterCallback {
    239     mutable llvm::Regex R;
    240 
    241   public:
    242     REFilter(std::string Regex) : R(Regex) {}
    243     bool operator()(const Multilib &M) const override {
    244       std::string Error;
    245       if (!R.isValid(Error)) {
    246         llvm::errs() << Error;
    247         assert(false);
    248         return false;
    249       }
    250       return R.match(M.gccSuffix());
    251     }
    252   };
    253 
    254   REFilter REF(Regex);
    255   filterInPlace(REF, Multilibs);
    256   return *this;
    257 }
    258 
    259 void MultilibSet::push_back(const Multilib &M) { Multilibs.push_back(M); }
    260 
    261 void MultilibSet::combineWith(const MultilibSet &Other) {
    262   Multilibs.insert(Multilibs.end(), Other.begin(), Other.end());
    263 }
    264 
    265 bool MultilibSet::select(const Multilib::flags_list &Flags, Multilib &M) const {
    266   class FilterFlagsMismatch : public MultilibSet::FilterCallback {
    267     llvm::StringMap<bool> FlagSet;
    268 
    269   public:
    270     FilterFlagsMismatch(const std::vector<std::string> &Flags) {
    271       // Stuff all of the flags into the FlagSet such that a true mappend
    272       // indicates the flag was enabled, and a false mappend indicates the
    273       // flag was disabled
    274       for (StringRef Flag : Flags)
    275         FlagSet[Flag.substr(1)] = isFlagEnabled(Flag);
    276     }
    277     bool operator()(const Multilib &M) const override {
    278       for (StringRef Flag : M.flags()) {
    279         llvm::StringMap<bool>::const_iterator SI = FlagSet.find(Flag.substr(1));
    280         if (SI != FlagSet.end())
    281           if (SI->getValue() != isFlagEnabled(Flag))
    282             return true;
    283       }
    284       return false;
    285     }
    286   private:
    287     bool isFlagEnabled(StringRef Flag) const {
    288       char Indicator = Flag.front();
    289       assert(Indicator == '+' || Indicator == '-');
    290       return Indicator == '+';
    291     }
    292   };
    293 
    294   FilterFlagsMismatch FlagsMismatch(Flags);
    295 
    296   multilib_list Filtered = filterCopy(FlagsMismatch, Multilibs);
    297 
    298   if (Filtered.size() == 0) {
    299     return false;
    300   } else if (Filtered.size() == 1) {
    301     M = Filtered[0];
    302     return true;
    303   }
    304 
    305   // TODO: pick the "best" multlib when more than one is suitable
    306   assert(false);
    307 
    308   return false;
    309 }
    310 
    311 void MultilibSet::print(raw_ostream &OS) const {
    312   for (const Multilib &M : *this)
    313     OS << M << "\n";
    314 }
    315 
    316 MultilibSet::multilib_list
    317 MultilibSet::filterCopy(const MultilibSet::FilterCallback &F,
    318                         const multilib_list &Ms) {
    319   multilib_list Copy(Ms);
    320   filterInPlace(F, Copy);
    321   return Copy;
    322 }
    323 
    324 void MultilibSet::filterInPlace(const MultilibSet::FilterCallback &F,
    325                                 multilib_list &Ms) {
    326   Ms.erase(std::remove_if(Ms.begin(), Ms.end(),
    327                           [&F](const Multilib &M) { return F(M); }),
    328            Ms.end());
    329 }
    330 
    331 raw_ostream &clang::driver::operator<<(raw_ostream &OS, const MultilibSet &MS) {
    332   MS.print(OS);
    333   return OS;
    334 }
    335