1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef TOOLS_GN_TARGET_H_ 6 #define TOOLS_GN_TARGET_H_ 7 8 #include <set> 9 #include <string> 10 #include <vector> 11 12 #include "base/basictypes.h" 13 #include "base/compiler_specific.h" 14 #include "base/logging.h" 15 #include "base/strings/string_piece.h" 16 #include "base/synchronization/lock.h" 17 #include "tools/gn/action_values.h" 18 #include "tools/gn/config_values.h" 19 #include "tools/gn/item.h" 20 #include "tools/gn/label_ptr.h" 21 #include "tools/gn/ordered_set.h" 22 #include "tools/gn/output_file.h" 23 #include "tools/gn/source_file.h" 24 #include "tools/gn/unique_vector.h" 25 26 class InputFile; 27 class Settings; 28 class Token; 29 class Toolchain; 30 31 class Target : public Item { 32 public: 33 enum OutputType { 34 UNKNOWN, 35 GROUP, 36 EXECUTABLE, 37 SHARED_LIBRARY, 38 STATIC_LIBRARY, 39 SOURCE_SET, 40 COPY_FILES, 41 ACTION, 42 ACTION_FOREACH, 43 }; 44 typedef std::vector<SourceFile> FileList; 45 typedef std::vector<std::string> StringVector; 46 47 Target(const Settings* settings, const Label& label); 48 virtual ~Target(); 49 50 // Returns a string naming the output type. 51 static const char* GetStringForOutputType(OutputType type); 52 53 // Item overrides. 54 virtual Target* AsTarget() OVERRIDE; 55 virtual const Target* AsTarget() const OVERRIDE; 56 virtual bool OnResolved(Err* err) OVERRIDE; 57 58 OutputType output_type() const { return output_type_; } 59 void set_output_type(OutputType t) { output_type_ = t; } 60 61 // Can be linked into other targets. 62 bool IsLinkable() const; 63 64 // Can have dependencies linked in. 65 bool IsFinal() const; 66 67 // Will be the empty string to use the target label as the output name. 68 // See GetComputedOutputName(). 69 const std::string& output_name() const { return output_name_; } 70 void set_output_name(const std::string& name) { output_name_ = name; } 71 72 // Returns the output name for this target, which is the output_name if 73 // specified, or the target label if not. If the flag is set, it will also 74 // include any output prefix specified on the tool (often "lib" on Linux). 75 // 76 // Because this depends on the tool for this target, the toolchain must 77 // have been set before calling. 78 std::string GetComputedOutputName(bool include_prefix) const; 79 80 const std::string& output_extension() const { return output_extension_; } 81 void set_output_extension(const std::string& extension) { 82 output_extension_ = extension; 83 } 84 85 const FileList& sources() const { return sources_; } 86 FileList& sources() { return sources_; } 87 88 // Set to true when all sources are public. This is the default. In this case 89 // the public headers list should be empty. 90 bool all_headers_public() const { return all_headers_public_; } 91 void set_all_headers_public(bool p) { all_headers_public_ = p; } 92 93 // When all_headers_public is false, this is the list of public headers. It 94 // could be empty which would mean no headers are public. 95 const FileList& public_headers() const { return public_headers_; } 96 FileList& public_headers() { return public_headers_; } 97 98 // Whether this target's includes should be checked by "gn check". 99 bool check_includes() const { return check_includes_; } 100 void set_check_includes(bool ci) { check_includes_ = ci; } 101 102 // Whether this static_library target should have code linked in. 103 bool complete_static_lib() const { return complete_static_lib_; } 104 void set_complete_static_lib(bool complete) { 105 DCHECK_EQ(STATIC_LIBRARY, output_type_); 106 complete_static_lib_ = complete; 107 } 108 109 bool testonly() const { return testonly_; } 110 void set_testonly(bool value) { testonly_ = value; } 111 112 // Compile-time extra dependencies. 113 const FileList& inputs() const { return inputs_; } 114 FileList& inputs() { return inputs_; } 115 116 // Runtime dependencies. 117 const FileList& data() const { return data_; } 118 FileList& data() { return data_; } 119 120 // Returns true if targets depending on this one should have an order 121 // dependency. 122 bool hard_dep() const { 123 return output_type_ == ACTION || 124 output_type_ == ACTION_FOREACH || 125 output_type_ == COPY_FILES; 126 } 127 128 // Linked private dependencies. 129 const LabelTargetVector& private_deps() const { return private_deps_; } 130 LabelTargetVector& private_deps() { return private_deps_; } 131 132 // Linked public dependencies. 133 const LabelTargetVector& public_deps() const { return public_deps_; } 134 LabelTargetVector& public_deps() { return public_deps_; } 135 136 // Non-linked dependencies. 137 const LabelTargetVector& data_deps() const { return data_deps_; } 138 LabelTargetVector& data_deps() { return data_deps_; } 139 140 // List of configs that this class inherits settings from. Once a target is 141 // resolved, this will also list all-dependent and public configs. 142 const UniqueVector<LabelConfigPair>& configs() const { return configs_; } 143 UniqueVector<LabelConfigPair>& configs() { return configs_; } 144 145 // List of configs that all dependencies (direct and indirect) of this 146 // target get. These configs are not added to this target. Note that due 147 // to the way this is computed, there may be duplicates in this list. 148 const UniqueVector<LabelConfigPair>& all_dependent_configs() const { 149 return all_dependent_configs_; 150 } 151 UniqueVector<LabelConfigPair>& all_dependent_configs() { 152 return all_dependent_configs_; 153 } 154 155 // List of configs that targets depending directly on this one get. These 156 // configs are also added to this target. 157 const UniqueVector<LabelConfigPair>& public_configs() const { 158 return public_configs_; 159 } 160 UniqueVector<LabelConfigPair>& public_configs() { 161 return public_configs_; 162 } 163 164 // A list of a subset of deps where we'll re-export public_configs as 165 // public_configs of this target. 166 const UniqueVector<LabelTargetPair>& forward_dependent_configs() const { 167 return forward_dependent_configs_; 168 } 169 UniqueVector<LabelTargetPair>& forward_dependent_configs() { 170 return forward_dependent_configs_; 171 } 172 173 // Dependencies that can include files from this target. 174 const std::set<Label>& allow_circular_includes_from() const { 175 return allow_circular_includes_from_; 176 } 177 std::set<Label>& allow_circular_includes_from() { 178 return allow_circular_includes_from_; 179 } 180 181 const UniqueVector<const Target*>& inherited_libraries() const { 182 return inherited_libraries_; 183 } 184 185 // This config represents the configuration set directly on this target. 186 ConfigValues& config_values() { return config_values_; } 187 const ConfigValues& config_values() const { return config_values_; } 188 189 ActionValues& action_values() { return action_values_; } 190 const ActionValues& action_values() const { return action_values_; } 191 192 const OrderedSet<SourceDir>& all_lib_dirs() const { return all_lib_dirs_; } 193 const OrderedSet<std::string>& all_libs() const { return all_libs_; } 194 195 const std::set<const Target*>& recursive_hard_deps() const { 196 return recursive_hard_deps_; 197 } 198 199 // The toolchain is only known once this target is resolved (all if its 200 // dependencies are known). They will be null until then. Generally, this can 201 // only be used during target writing. 202 const Toolchain* toolchain() const { return toolchain_; } 203 204 // Sets the toolchain. The toolchain must include a tool for this target 205 // or the error will be set and the function will return false. Unusually, 206 // this function's "err" output is optional since this is commonly used 207 // frequently by unit tests which become needlessly verbose. 208 bool SetToolchain(const Toolchain* toolchain, Err* err = NULL); 209 210 // Returns outputs from this target. The link output file is the one that 211 // other targets link to when they depend on this target. This will only be 212 // valid for libraries and will be empty for all other target types. 213 // 214 // The dependency output file is the file that should be used to express 215 // a dependency on this one. It could be the same as the link output file 216 // (this will be the case for static libraries). For shared libraries it 217 // could be the same or different than the link output file, depending on the 218 // system. For actions this will be the stamp file. 219 // 220 // These are only known once the target is resolved and will be empty before 221 // that. This is a cache of the files to prevent every target that depends on 222 // a given library from recomputing the same pattern. 223 const OutputFile& link_output_file() const { 224 return link_output_file_; 225 } 226 const OutputFile& dependency_output_file() const { 227 return dependency_output_file_; 228 } 229 230 private: 231 // Pulls necessary information from dependencies to this one when all 232 // dependencies have been resolved. 233 void PullDependentTargetInfo(); 234 235 // These each pull specific things from dependencies to this one when all 236 // deps have been resolved. 237 void PullForwardedDependentConfigs(); 238 void PullForwardedDependentConfigsFrom(const Target* from); 239 void PullRecursiveHardDeps(); 240 241 // Fills the link and dependency output files when a target is resolved. 242 void FillOutputFiles(); 243 244 // Validates the given thing when a target is resolved. 245 bool CheckVisibility(Err* err) const; 246 bool CheckTestonly(Err* err) const; 247 bool CheckNoNestedStaticLibs(Err* err) const; 248 249 OutputType output_type_; 250 std::string output_name_; 251 std::string output_extension_; 252 253 FileList sources_; 254 bool all_headers_public_; 255 FileList public_headers_; 256 bool check_includes_; 257 bool complete_static_lib_; 258 bool testonly_; 259 FileList inputs_; 260 FileList data_; 261 262 bool hard_dep_; 263 264 LabelTargetVector private_deps_; 265 LabelTargetVector public_deps_; 266 LabelTargetVector data_deps_; 267 268 UniqueVector<LabelConfigPair> configs_; 269 UniqueVector<LabelConfigPair> all_dependent_configs_; 270 UniqueVector<LabelConfigPair> public_configs_; 271 UniqueVector<LabelTargetPair> forward_dependent_configs_; 272 273 std::set<Label> allow_circular_includes_from_; 274 275 bool external_; 276 277 // Static libraries and source sets from transitive deps. These things need 278 // to be linked only with the end target (executable, shared library). Source 279 // sets do not get pushed beyond static library boundaries, and neither 280 // source sets nor static libraries get pushed beyond sahred library 281 // boundaries. 282 UniqueVector<const Target*> inherited_libraries_; 283 284 // These libs and dirs are inherited from statically linked deps and all 285 // configs applying to this target. 286 OrderedSet<SourceDir> all_lib_dirs_; 287 OrderedSet<std::string> all_libs_; 288 289 // All hard deps from this target and all dependencies. Filled in when this 290 // target is marked resolved. This will not include the current target. 291 std::set<const Target*> recursive_hard_deps_; 292 293 ConfigValues config_values_; // Used for all binary targets. 294 ActionValues action_values_; // Used for action[_foreach] targets. 295 296 // Toolchain used by this target. Null until target is resolved. 297 const Toolchain* toolchain_; 298 299 // Output files. Null until the target is resolved. 300 OutputFile link_output_file_; 301 OutputFile dependency_output_file_; 302 303 DISALLOW_COPY_AND_ASSIGN(Target); 304 }; 305 306 namespace BASE_HASH_NAMESPACE { 307 308 #if defined(COMPILER_GCC) 309 template<> struct hash<const Target*> { 310 std::size_t operator()(const Target* t) const { 311 return reinterpret_cast<std::size_t>(t); 312 } 313 }; 314 #elif defined(COMPILER_MSVC) 315 inline size_t hash_value(const Target* t) { 316 return reinterpret_cast<size_t>(t); 317 } 318 #endif // COMPILER... 319 320 } // namespace BASE_HASH_NAMESPACE 321 322 #endif // TOOLS_GN_TARGET_H_ 323