1//===- subzero/src/IceClFlags.h - Cl Flags for translation ------*- C++ -*-===//
2//
3// The Subzero Code Generator
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9///
10/// \file
11/// \brief Declares Ice::ClFlags which implements command line processing.
12///
13//===----------------------------------------------------------------------===//
14
15#ifndef SUBZERO_SRC_ICECLFLAGS_H
16#define SUBZERO_SRC_ICECLFLAGS_H
17
18#include "IceDefs.h"
19#include "IceBuildDefs.h"
20#include "IceClFlags.def"
21#include "IceRangeSpec.h"
22#include "IceTypes.h"
23
24#ifdef __clang__
25#pragma clang diagnostic push
26#pragma clang diagnostic ignored "-Wunused-parameter"
27#endif // __clang__
28
29#include "llvm/IRReader/IRReader.h"
30
31#ifdef __clang__
32#pragma clang diagnostic pop
33#endif // __clang__
34
35#include <string>
36#include <utility>
37#include <vector>
38
39#ifndef PNACL_LLVM
40namespace llvm {
41// \brief Define the expected format of the file.
42enum NaClFileFormat {
43 // LLVM IR source or bitcode file (as appropriate).
44 LLVMFormat,
45 // PNaCl bitcode file.
46 PNaClFormat,
47 // Autodetect if PNaCl or LLVM format.
48 AutodetectFileFormat
49};
50} // end of namespace llvm
51#endif // !PNACL_LLVM
52
53namespace Ice {
54// detail defines the type cl_type_traits, which is used to define the
55// getters/setters for the ClFlags class. It converts the cl_detail::*_flag
56// types to appropriate types for the several getters and setters created.
57namespace detail {
58// Base cl_type_traits.
59template <typename B, typename CL> struct cl_type_traits {};
60
61// cl_type_traits specialized cl::list<std::string>, non-MINIMAL build.
62template <> struct cl_type_traits<std::string, cl_detail::dev_list_flag> {
63 using storage_type = std::vector<std::string>;
64};
65
66// cl_type_traits specialized cl::list<Ice::VerboseItem>, non-MINIMAL build.
67template <> struct cl_type_traits<Ice::VerboseItem, cl_detail::dev_list_flag> {
68 using storage_type = Ice::VerboseMask;
69};
70
71// cl_type_traits specialized cl::opt<T>, non-MINIMAL build.
72template <typename T> struct cl_type_traits<T, cl_detail::dev_opt_flag> {
73 using storage_type = T;
74};
75
76// cl_type_traits specialized cl::opt<T>, MINIMAL build.
77template <typename T> struct cl_type_traits<T, cl_detail::release_opt_flag> {
78 using storage_type = T;
79};
80
81} // end of namespace detail
82
83/// Define variables which configure translation and related support functions.
84class ClFlags {
85 ClFlags(const ClFlags &) = delete;
86 ClFlags &operator=(const ClFlags &) = delete;
87
88public:
89 /// User defined constructor.
90 ClFlags() { resetClFlags(); }
91
92 /// The command line flags.
93 static ClFlags Flags;
94
95 /// \brief Parse commmand line options for Subzero.
96 ///
97 /// This is done use cl::ParseCommandLineOptions() and the static variables of
98 /// type cl::opt defined in IceClFlags.cpp
99 static void parseFlags(int argc, const char *const *argv);
100
101 /// Reset all configuration options to their nominal values.
102 void resetClFlags();
103
104 /// \brief Retrieve the configuration option state
105 ///
106 /// This is defined by static variables
107 /// anonymous_namespace{IceClFlags.cpp}::AllowErrorRecoveryObj,
108 /// anonymous_namespace{IceClFlags.cpp}::AllowIacaMarksObj,
109 /// ...
110 static void getParsedClFlags(ClFlags &OutFlags);
111
112#define X(Name, Type, ClType, ...) \
113private: \
114 using Name##StorageType = \
115 detail::cl_type_traits<Type, cl_detail::ClType>::storage_type; \
116 \
117 Name##StorageType Name; \
118 \
119 template <bool E> \
120 typename std::enable_if<E, void>::type set##Name##Impl( \
121 Name##StorageType Value) { \
122 Name = std::move(Value); \
123 } \
124 \
125 template <bool E> \
126 typename std::enable_if<!E, void>::type set##Name##Impl(Name##StorageType) { \
127 } \
128 \
129public: \
130 Name##StorageType get##Name() const { return Name; } \
131 void set##Name(Name##StorageType Value) { \
132 /* TODO(jpp): figure out which optional flags are used in minimal, and \
133 what are the defaults for them. */ \
134 static constexpr bool Enable = \
135 std::is_same<cl_detail::ClType, cl_detail::release_opt_flag>::value || \
136 !BuildDefs::minimal() || true; \
137 set##Name##Impl<Enable>(std::move(Value)); \
138 } \
139 \
140private:
141 COMMAND_LINE_FLAGS
142#undef X
143
144public:
145 bool isSequential() const { return NumTranslationThreads == 0; }
146 bool isParseParallel() const {
147 return getParseParallel() && !isSequential() && getBuildOnRead();
148 }
149 std::string getAppName() const { return AppName; }
150 void setAppName(const std::string &Value) { AppName = Value; }
151
152 /// \brief Get the value of ClFlags::GenerateUnitTestMessages
153 ///
154 /// Note: If dump routines have been turned off, the error messages
155 /// will not be readable. Hence, turn off.
156 bool getGenerateUnitTestMessages() const {
157 return !BuildDefs::dump() || GenerateUnitTestMessages;
158 }
159 /// Set ClFlags::GenerateUnitTestMessages to a new value
160 void setGenerateUnitTestMessages(bool NewValue) {
161 GenerateUnitTestMessages = NewValue;
162 }
163 bool matchForceO2(GlobalString Name, uint32_t Number) const {
164 return ForceO2.match(Name, Number);
165 }
166 bool matchSplitInsts(const std::string &Name, uint32_t Number) const {
167 return SplitInsts.match(Name, Number);
168 }
169 bool matchTestStatus(GlobalString Name, uint32_t Number) const {
170 return TestStatus.match(Name, Number);
171 }
172 bool matchTimingFocus(GlobalString Name, uint32_t Number) const {
173 return TimingFocus.match(Name, Number);
174 }
175 bool matchTranslateOnly(GlobalString Name, uint32_t Number) const {
176 return TranslateOnly.match(Name, Number);
177 }
178 bool matchVerboseFocusOn(GlobalString Name, uint32_t Number) const {
179 return VerboseFocus.match(Name, Number);
180 }
181 bool matchVerboseFocusOn(const std::string &Name, uint32_t Number) const {
182 return VerboseFocus.match(Name, Number);
183 }
184
185private:
186 std::string AppName;
187
188 /// Initialized to false; not set by the command line.
189 bool GenerateUnitTestMessages;
190
191 RangeSpec ForceO2;
192 RangeSpec SplitInsts;
193 RangeSpec TestStatus;
194 RangeSpec TimingFocus;
195 RangeSpec TranslateOnly;
196 RangeSpec VerboseFocus;
197};
198
199inline const ClFlags &getFlags() { return ClFlags::Flags; }
200
201} // end of namespace Ice
202
203#endif // SUBZERO_SRC_ICECLFLAGS_H
204