llvm/lib/Option/Option.cpp

   1 //===- Option.cpp - Abstract Driver Options -------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/ADT/StringRef.h"
  10 #include "llvm/ADT/Twine.h"
  11 #include "llvm/Config/llvm-config.h"
  12 #include "llvm/Option/Arg.h"
  13 #include "llvm/Option/ArgList.h"
  14 #include "llvm/Option/Option.h"
  15 #include "llvm/Option/OptTable.h"
  16 #include "llvm/Support/Compiler.h"
  17 #include "llvm/Support/Debug.h"
  18 #include "llvm/Support/ErrorHandling.h"
  19 #include "llvm/Support/raw_ostream.h"
  20 #include <cassert>
  21 #include <cstring>
  22
  23 using namespace llvm;
  24 using namespace llvm::opt;
  25
  26 Option::Option(const OptTable::Info *info, const OptTable *owner)
  27   : Info(info), Owner(owner) {
  28   // Multi-level aliases are not supported. This just simplifies option
  29   // tracking, it is not an inherent limitation.
  30   assert((!Info || !getAlias().isValid() || !getAlias().getAlias().isValid()) &&
  31          "Multi-level aliases are not supported.");
  32
  33   if (Info && getAliasArgs()) {
  34     assert(getAlias().isValid() && "Only alias options can have alias args.");
  35     assert(getKind() == FlagClass && "Only Flag aliases can have alias args.");
  36     assert(getAlias().getKind() != FlagClass &&
  37            "Cannot provide alias args to a flag option.");
  38   }
  39 }
  40
  41 void Option::print(raw_ostream &O, bool AddNewLine) const {
  42   O << "<";
  43   switch (getKind()) {
  44 #define P(N) case N: O << #N; break
  45     P(GroupClass);
  46     P(InputClass);
  47     P(UnknownClass);
  48     P(FlagClass);
  49     P(JoinedClass);
  50     P(ValuesClass);
  51     P(SeparateClass);
  52     P(CommaJoinedClass);
  53     P(MultiArgClass);
  54     P(JoinedOrSeparateClass);
  55     P(JoinedAndSeparateClass);
  56     P(RemainingArgsClass);
  57     P(RemainingArgsJoinedClass);
  58 #undef P
  59   }
  60
  61   if (!Info->Prefixes.empty()) {
  62     O << " Prefixes:[";
  63     for (size_t I = 0, N = Info->Prefixes.size(); I != N; ++I)
  64       O << '"' << Info->Prefixes[I] << (I == N - 1 ? "\"" : "\", ");
  65     O << ']';
  66   }
  67
  68   O << " Name:\"" << getName() << '"';
  69
  70   const Option Group = getGroup();
  71   if (Group.isValid()) {
  72     O << " Group:";
  73     Group.print(O, /*AddNewLine=*/false);
  74   }
  75
  76   const Option Alias = getAlias();
  77   if (Alias.isValid()) {
  78     O << " Alias:";
  79     Alias.print(O, /*AddNewLine=*/false);
  80   }
  81
  82   if (getKind() == MultiArgClass)
  83     O << " NumArgs:" << getNumArgs();
  84
  85   O << ">";
  86   if (AddNewLine)
  87     O << "\n";
  88 }
  89
  90 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
  91 LLVM_DUMP_METHOD void Option::dump() const { print(dbgs()); }
  92 #endif
  93
  94 bool Option::matches(OptSpecifier Opt) const {
  95   // Aliases are never considered in matching, look through them.
  96   const Option Alias = getAlias();
  97   if (Alias.isValid())
  98     return Alias.matches(Opt);
  99
 100   // Check exact match.
 101   if (getID() == Opt.getID())
 102     return true;
 103
 104   const Option Group = getGroup();
 105   if (Group.isValid())
 106     return Group.matches(Opt);
 107   return false;
 108 }
 109
 110 std::unique_ptr<Arg> Option::acceptInternal(const ArgList &Args,
 111                                             StringRef Spelling,
 112                                             unsigned &Index) const {
 113   const size_t SpellingSize = Spelling.size();
 114   const size_t ArgStringSize = StringRef(Args.getArgString(Index)).size();
 115   switch (getKind()) {
 116   case FlagClass: {
 117     if (SpellingSize != ArgStringSize)
 118       return nullptr;
 119     return std::make_unique<Arg>(*this, Spelling, Index++);
 120   }
 121   case JoinedClass: {
 122     const char *Value = Args.getArgString(Index) + SpellingSize;
 123     return std::make_unique<Arg>(*this, Spelling, Index++, Value);
 124   }
 125   case CommaJoinedClass: {
 126     // Always matches.
 127     const char *Str = Args.getArgString(Index) + SpellingSize;
 128     auto A = std::make_unique<Arg>(*this, Spelling, Index++);
 129
 130     // Parse out the comma separated values.
 131     const char *Prev = Str;
 132     for (;; ++Str) {
 133       char c = *Str;
 134
 135       if (!c || c == ',') {
 136         if (Prev != Str) {
 137           char *Value = new char[Str - Prev + 1];
 138           memcpy(Value, Prev, Str - Prev);
 139           Value[Str - Prev] = '\0';
 140           A->getValues().push_back(Value);
 141         }
 142
 143         if (!c)
 144           break;
 145
 146         Prev = Str + 1;
 147       }
 148     }
 149     A->setOwnsValues(true);
 150
 151     return A;
 152   }
 153   case SeparateClass:
 154     // Matches iff this is an exact match.
 155     if (SpellingSize != ArgStringSize)
 156       return nullptr;
 157
 158     Index += 2;
 159     if (Index > Args.getNumInputArgStrings() ||
 160         Args.getArgString(Index - 1) == nullptr)
 161       return nullptr;
 162
 163     return std::make_unique<Arg>(*this, Spelling, Index - 2,
 164                                  Args.getArgString(Index - 1));
 165   case MultiArgClass: {
 166     // Matches iff this is an exact match.
 167     if (SpellingSize != ArgStringSize)
 168       return nullptr;
 169
 170     Index += 1 + getNumArgs();
 171     if (Index > Args.getNumInputArgStrings())
 172       return nullptr;
 173
 174     auto A = std::make_unique<Arg>(*this, Spelling, Index - 1 - getNumArgs(),
 175                                    Args.getArgString(Index - getNumArgs()));
 176     for (unsigned i = 1; i != getNumArgs(); ++i)
 177       A->getValues().push_back(Args.getArgString(Index - getNumArgs() + i));
 178     return A;
 179   }
 180   case JoinedOrSeparateClass: {
 181     // If this is not an exact match, it is a joined arg.
 182     if (SpellingSize != ArgStringSize) {
 183       const char *Value = Args.getArgString(Index) + SpellingSize;
 184       return std::make_unique<Arg>(*this, Spelling, Index++, Value);
 185     }
 186
 187     // Otherwise it must be separate.
 188     Index += 2;
 189     if (Index > Args.getNumInputArgStrings() ||
 190         Args.getArgString(Index - 1) == nullptr)
 191       return nullptr;
 192
 193     return std::make_unique<Arg>(*this, Spelling, Index - 2,
 194                                  Args.getArgString(Index - 1));
 195   }
 196   case JoinedAndSeparateClass:
 197     // Always matches.
 198     Index += 2;
 199     if (Index > Args.getNumInputArgStrings() ||
 200         Args.getArgString(Index - 1) == nullptr)
 201       return nullptr;
 202
 203     return std::make_unique<Arg>(*this, Spelling, Index - 2,
 204                                  Args.getArgString(Index - 2) + SpellingSize,
 205                                  Args.getArgString(Index - 1));
 206   case RemainingArgsClass: {
 207     // Matches iff this is an exact match.
 208     if (SpellingSize != ArgStringSize)
 209       return nullptr;
 210     auto A = std::make_unique<Arg>(*this, Spelling, Index++);
 211     while (Index < Args.getNumInputArgStrings() &&
 212            Args.getArgString(Index) != nullptr)
 213       A->getValues().push_back(Args.getArgString(Index++));
 214     return A;
 215   }
 216   case RemainingArgsJoinedClass: {
 217     auto A = std::make_unique<Arg>(*this, Spelling, Index);
 218     if (SpellingSize != ArgStringSize) {
 219       // An inexact match means there is a joined arg.
 220       A->getValues().push_back(Args.getArgString(Index) + SpellingSize);
 221     }
 222     Index++;
 223     while (Index < Args.getNumInputArgStrings() &&
 224            Args.getArgString(Index) != nullptr)
 225       A->getValues().push_back(Args.getArgString(Index++));
 226     return A;
 227   }
 228
 229   default:
 230     llvm_unreachable("Invalid option kind!");
 231   }
 232 }
 233
 234 std::unique_ptr<Arg> Option::accept(const ArgList &Args, StringRef CurArg,
 235                                     bool GroupedShortOption,
 236                                     unsigned &Index) const {
 237   auto A(GroupedShortOption && getKind() == FlagClass
 238                              ? std::make_unique<Arg>(*this, CurArg, Index)
 239                              : acceptInternal(Args, CurArg, Index));
 240   if (!A)
 241     return nullptr;
 242
 243   const Option &UnaliasedOption = getUnaliasedOption();
 244   if (getID() == UnaliasedOption.getID())
 245     return A;
 246
 247   // "A" is an alias for a different flag. For most clients it's more convenient
 248   // if this function returns unaliased Args, so create an unaliased arg for
 249   // returning.
 250
 251   // This creates a completely new Arg object for the unaliased Arg because
 252   // the alias and the unaliased arg can have different Kinds and different
 253   // Values (due to AliasArgs<>).
 254
 255   // Get the spelling from the unaliased option.
 256   StringRef UnaliasedSpelling = Args.MakeArgString(
 257       Twine(UnaliasedOption.getPrefix()) + Twine(UnaliasedOption.getName()));
 258
 259   // It's a bit weird that aliased and unaliased arg share one index, but
 260   // the index is mostly use as a memory optimization in render().
 261   // Due to this, ArgList::getArgString(A->getIndex()) will return the spelling
 262   // of the aliased arg always, while A->getSpelling() returns either the
 263   // unaliased or the aliased arg, depending on which Arg object it's called on.
 264   auto UnaliasedA =
 265       std::make_unique<Arg>(UnaliasedOption, UnaliasedSpelling, A->getIndex());
 266   Arg *RawA = A.get();
 267   UnaliasedA->setAlias(std::move(A));
 268
 269   if (getKind() != FlagClass) {
 270     // Values are usually owned by the ArgList. The exception are
 271     // CommaJoined flags, where the Arg owns the values. For aliased flags,
 272     // make the unaliased Arg the owner of the values.
 273     // FIXME: There aren't many uses of CommaJoined -- try removing
 274     // CommaJoined in favor of just calling StringRef::split(',') instead.
 275     UnaliasedA->getValues() = RawA->getValues();
 276     UnaliasedA->setOwnsValues(RawA->getOwnsValues());
 277     RawA->setOwnsValues(false);
 278     return UnaliasedA;
 279   }
 280
 281   // FlagClass aliases can have AliasArgs<>; add those to the unaliased arg.
 282   if (const char *Val = getAliasArgs()) {
 283     while (*Val != '\0') {
 284       UnaliasedA->getValues().push_back(Val);
 285
 286       // Move past the '\0' to the next argument.
 287       Val += strlen(Val) + 1;
 288     }
 289   }
 290   if (UnaliasedOption.getKind() == JoinedClass && !getAliasArgs())
 291     // A Flag alias for a Joined option must provide an argument.
 292     UnaliasedA->getValues().push_back("");
 293   return UnaliasedA;
 294 }