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) 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);
  74   }
  75
  76   const Option Alias = getAlias();
  77   if (Alias.isValid()) {
  78     O << " Alias:";
  79     Alias.print(O);
  80   }
  81
  82   if (getKind() == MultiArgClass)
  83     O << " NumArgs:" << getNumArgs();
  84
  85   O << ">\n";
  86 }
  87
  88 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
  89 LLVM_DUMP_METHOD void Option::dump() const { print(dbgs()); }
  90 #endif
  91
  92 bool Option::matches(OptSpecifier Opt) const {
  93   // Aliases are never considered in matching, look through them.
  94   const Option Alias = getAlias();
  95   if (Alias.isValid())
  96     return Alias.matches(Opt);
  97
  98   // Check exact match.
  99   if (getID() == Opt.getID())
 100     return true;
 101
 102   const Option Group = getGroup();
 103   if (Group.isValid())
 104     return Group.matches(Opt);
 105   return false;
 106 }
 107
 108 std::unique_ptr<Arg> Option::acceptInternal(const ArgList &Args,
 109                                             StringRef Spelling,
 110                                             unsigned &Index) const {
 111   const size_t SpellingSize = Spelling.size();
 112   const size_t ArgStringSize = StringRef(Args.getArgString(Index)).size();
 113   switch (getKind()) {
 114   case FlagClass: {
 115     if (SpellingSize != ArgStringSize)
 116       return nullptr;
 117     return std::make_unique<Arg>(*this, Spelling, Index++);
 118   }
 119   case JoinedClass: {
 120     const char *Value = Args.getArgString(Index) + SpellingSize;
 121     return std::make_unique<Arg>(*this, Spelling, Index++, Value);
 122   }
 123   case CommaJoinedClass: {
 124     // Always matches.
 125     const char *Str = Args.getArgString(Index) + SpellingSize;
 126     auto A = std::make_unique<Arg>(*this, Spelling, Index++);
 127
 128     // Parse out the comma separated values.
 129     const char *Prev = Str;
 130     for (;; ++Str) {
 131       char c = *Str;
 132
 133       if (!c || c == ',') {
 134         if (Prev != Str) {
 135           char *Value = new char[Str - Prev + 1];
 136           memcpy(Value, Prev, Str - Prev);
 137           Value[Str - Prev] = '\0';
 138           A->getValues().push_back(Value);
 139         }
 140
 141         if (!c)
 142           break;
 143
 144         Prev = Str + 1;
 145       }
 146     }
 147     A->setOwnsValues(true);
 148
 149     return A;
 150   }
 151   case SeparateClass:
 152     // Matches iff this is an exact match.
 153     if (SpellingSize != ArgStringSize)
 154       return nullptr;
 155
 156     Index += 2;
 157     if (Index > Args.getNumInputArgStrings() ||
 158         Args.getArgString(Index - 1) == nullptr)
 159       return nullptr;
 160
 161     return std::make_unique<Arg>(*this, Spelling, Index - 2,
 162                                  Args.getArgString(Index - 1));
 163   case MultiArgClass: {
 164     // Matches iff this is an exact match.
 165     if (SpellingSize != ArgStringSize)
 166       return nullptr;
 167
 168     Index += 1 + getNumArgs();
 169     if (Index > Args.getNumInputArgStrings())
 170       return nullptr;
 171
 172     auto A = std::make_unique<Arg>(*this, Spelling, Index - 1 - getNumArgs(),
 173                                    Args.getArgString(Index - getNumArgs()));
 174     for (unsigned i = 1; i != getNumArgs(); ++i)
 175       A->getValues().push_back(Args.getArgString(Index - getNumArgs() + i));
 176     return A;
 177   }
 178   case JoinedOrSeparateClass: {
 179     // If this is not an exact match, it is a joined arg.
 180     if (SpellingSize != ArgStringSize) {
 181       const char *Value = Args.getArgString(Index) + SpellingSize;
 182       return std::make_unique<Arg>(*this, Spelling, Index++, Value);
 183     }
 184
 185     // Otherwise it must be separate.
 186     Index += 2;
 187     if (Index > Args.getNumInputArgStrings() ||
 188         Args.getArgString(Index - 1) == nullptr)
 189       return nullptr;
 190
 191     return std::make_unique<Arg>(*this, Spelling, Index - 2,
 192                                  Args.getArgString(Index - 1));
 193   }
 194   case JoinedAndSeparateClass:
 195     // Always matches.
 196     Index += 2;
 197     if (Index > Args.getNumInputArgStrings() ||
 198         Args.getArgString(Index - 1) == nullptr)
 199       return nullptr;
 200
 201     return std::make_unique<Arg>(*this, Spelling, Index - 2,
 202                                  Args.getArgString(Index - 2) + SpellingSize,
 203                                  Args.getArgString(Index - 1));
 204   case RemainingArgsClass: {
 205     // Matches iff this is an exact match.
 206     if (SpellingSize != ArgStringSize)
 207       return nullptr;
 208     auto A = std::make_unique<Arg>(*this, Spelling, Index++);
 209     while (Index < Args.getNumInputArgStrings() &&
 210            Args.getArgString(Index) != nullptr)
 211       A->getValues().push_back(Args.getArgString(Index++));
 212     return A;
 213   }
 214   case RemainingArgsJoinedClass: {
 215     auto A = std::make_unique<Arg>(*this, Spelling, Index);
 216     if (SpellingSize != ArgStringSize) {
 217       // An inexact match means there is a joined arg.
 218       A->getValues().push_back(Args.getArgString(Index) + SpellingSize);
 219     }
 220     Index++;
 221     while (Index < Args.getNumInputArgStrings() &&
 222            Args.getArgString(Index) != nullptr)
 223       A->getValues().push_back(Args.getArgString(Index++));
 224     return A;
 225   }
 226
 227   default:
 228     llvm_unreachable("Invalid option kind!");
 229   }
 230 }
 231
 232 std::unique_ptr<Arg> Option::accept(const ArgList &Args, StringRef CurArg,
 233                                     bool GroupedShortOption,
 234                                     unsigned &Index) const {
 235   auto A(GroupedShortOption && getKind() == FlagClass
 236                              ? std::make_unique<Arg>(*this, CurArg, Index)
 237                              : acceptInternal(Args, CurArg, Index));
 238   if (!A)
 239     return nullptr;
 240
 241   const Option &UnaliasedOption = getUnaliasedOption();
 242   if (getID() == UnaliasedOption.getID())
 243     return A;
 244
 245   // "A" is an alias for a different flag. For most clients it's more convenient
 246   // if this function returns unaliased Args, so create an unaliased arg for
 247   // returning.
 248
 249   // This creates a completely new Arg object for the unaliased Arg because
 250   // the alias and the unaliased arg can have different Kinds and different
 251   // Values (due to AliasArgs<>).
 252
 253   // Get the spelling from the unaliased option.
 254   StringRef UnaliasedSpelling = Args.MakeArgString(
 255       Twine(UnaliasedOption.getPrefix()) + Twine(UnaliasedOption.getName()));
 256
 257   // It's a bit weird that aliased and unaliased arg share one index, but
 258   // the index is mostly use as a memory optimization in render().
 259   // Due to this, ArgList::getArgString(A->getIndex()) will return the spelling
 260   // of the aliased arg always, while A->getSpelling() returns either the
 261   // unaliased or the aliased arg, depending on which Arg object it's called on.
 262   auto UnaliasedA =
 263       std::make_unique<Arg>(UnaliasedOption, UnaliasedSpelling, A->getIndex());
 264   Arg *RawA = A.get();
 265   UnaliasedA->setAlias(std::move(A));
 266
 267   if (getKind() != FlagClass) {
 268     // Values are usually owned by the ArgList. The exception are
 269     // CommaJoined flags, where the Arg owns the values. For aliased flags,
 270     // make the unaliased Arg the owner of the values.
 271     // FIXME: There aren't many uses of CommaJoined -- try removing
 272     // CommaJoined in favor of just calling StringRef::split(',') instead.
 273     UnaliasedA->getValues() = RawA->getValues();
 274     UnaliasedA->setOwnsValues(RawA->getOwnsValues());
 275     RawA->setOwnsValues(false);
 276     return UnaliasedA;
 277   }
 278
 279   // FlagClass aliases can have AliasArgs<>; add those to the unaliased arg.
 280   if (const char *Val = getAliasArgs()) {
 281     while (*Val != '\0') {
 282       UnaliasedA->getValues().push_back(Val);
 283
 284       // Move past the '\0' to the next argument.
 285       Val += strlen(Val) + 1;
 286     }
 287   }
 288   if (UnaliasedOption.getKind() == JoinedClass && !getAliasArgs())
 289     // A Flag alias for a Joined option must provide an argument.
 290     UnaliasedA->getValues().push_back("");
 291   return UnaliasedA;
 292 }