Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Option/Arg.h
Line
Count
Source (jump to first uncovered line)
1
//===- Arg.h - Parsed Argument Classes --------------------------*- C++ -*-===//
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
/// \file
10
/// Defines the llvm::Arg class for parsed arguments.
11
///
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_OPTION_ARG_H
15
#define LLVM_OPTION_ARG_H
16
17
#include "llvm/ADT/SmallVector.h"
18
#include "llvm/ADT/StringRef.h"
19
#include "llvm/Option/Option.h"
20
#include <string>
21
22
namespace llvm {
23
24
class raw_ostream;
25
26
namespace opt {
27
28
class ArgList;
29
30
/// A concrete instance of a particular driver option.
31
///
32
/// The Arg class encodes just enough information to be able to
33
/// derive the argument values efficiently.
34
class Arg {
35
private:
36
  /// The option this argument is an instance of.
37
  const Option Opt;
38
39
  /// The argument this argument was derived from (during tool chain
40
  /// argument translation), if any.
41
  const Arg *BaseArg;
42
43
  /// How this instance of the option was spelled.
44
  StringRef Spelling;
45
46
  /// The index at which this argument appears in the containing
47
  /// ArgList.
48
  unsigned Index;
49
50
  /// Was this argument used to effect compilation?
51
  ///
52
  /// This is used for generating "argument unused" diagnostics.
53
  mutable unsigned Claimed : 1;
54
55
  /// Does this argument own its values?
56
  mutable unsigned OwnsValues : 1;
57
58
  /// The argument values, as C strings.
59
  SmallVector<const char *, 2> Values;
60
61
  /// If this arg was created through an alias, this is the original alias arg.
62
  /// For example, *this might be "-finput-charset=utf-8" and Alias might
63
  /// point to an arg representing "/source-charset:utf-8".
64
  std::unique_ptr<Arg> Alias;
65
66
public:
67
  Arg(const Option Opt, StringRef Spelling, unsigned Index,
68
      const Arg *BaseArg = nullptr);
69
  Arg(const Option Opt, StringRef Spelling, unsigned Index,
70
      const char *Value0, const Arg *BaseArg = nullptr);
71
  Arg(const Option Opt, StringRef Spelling, unsigned Index,
72
      const char *Value0, const char *Value1, const Arg *BaseArg = nullptr);
73
  Arg(const Arg &) = delete;
74
  Arg &operator=(const Arg &) = delete;
75
  ~Arg();
76
77
42.0M
  const Option &getOption() const { return Opt; }
78
79
  /// Returns the used prefix and name of the option:
80
  /// For `--foo=bar`, returns `--foo=`.
81
  /// This is often the wrong function to call:
82
  /// * Use `getValue()` to get `bar`.
83
  /// * Use `getAsString()` to get a string suitable for printing an Arg in
84
  ///   a diagnostic.
85
452k
  StringRef getSpelling() const { return Spelling; }
86
87
99.7k
  unsigned getIndex() const { return Index; }
88
89
  /// Return the base argument which generated this arg.
90
  ///
91
  /// This is either the argument itself or the argument it was
92
  /// derived from during tool chain specific argument translation.
93
3.59M
  const Arg &getBaseArg() const {
94
3.59M
    return BaseArg ? 
*BaseArg1.89k
:
*this3.59M
;
95
3.59M
  }
96
41
  void setBaseArg(const Arg *BaseArg) { this->BaseArg = BaseArg; }
97
98
  /// Args are converted to their unaliased form.  For args that originally
99
  /// came from an alias, this returns the alias the arg was produced from.
100
0
  const Arg* getAlias() const { return Alias.get(); }
101
46.8k
  void setAlias(std::unique_ptr<Arg> Alias) { this->Alias = std::move(Alias); }
102
103
44.0k
  bool getOwnsValues() const { return OwnsValues; }
104
105k
  void setOwnsValues(bool Value) const { OwnsValues = Value; }
105
106
689k
  bool isClaimed() const { return getBaseArg().Claimed; }
107
108
  /// Set the Arg claimed bit.
109
2.90M
  void claim() const { getBaseArg().Claimed = true; }
110
111
35.0k
  unsigned getNumValues() const { return Values.size(); }
112
113
1.51M
  const char *getValue(unsigned N = 0) const {
114
1.51M
    return Values[N];
115
1.51M
  }
116
117
351k
  SmallVectorImpl<const char *> &getValues() { return Values; }
118
276
  const SmallVectorImpl<const char *> &getValues() const { return Values; }
119
120
23.1k
  bool containsValue(StringRef Value) const {
121
46.5k
    for (unsigned i = 0, e = getNumValues(); i != e; 
++i23.3k
)
122
23.4k
      if (Values[i] == Value)
123
64
        return true;
124
23.1k
    
return false23.1k
;
125
23.1k
  }
126
127
  /// Append the argument onto the given array as strings.
128
  void render(const ArgList &Args, ArgStringList &Output) const;
129
130
  /// Append the argument, render as an input, onto the given
131
  /// array as strings.
132
  ///
133
  /// The distinction is that some options only render their values
134
  /// when rendered as a input (e.g., Xlinker).
135
  void renderAsInput(const ArgList &Args, ArgStringList &Output) const;
136
137
  void print(raw_ostream &O) const;
138
  void dump() const;
139
140
  /// Return a formatted version of the argument and its values, for
141
  /// diagnostics. Since this is for diagnostics, if this Arg was produced
142
  /// through an alias, this returns the string representation of the alias
143
  /// that the user wrote.
144
  std::string getAsString(const ArgList &Args) const;
145
};
146
147
} // end namespace opt
148
149
} // end namespace llvm
150
151
#endif // LLVM_OPTION_ARG_H