1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef TOOLS_GN_TOOLCHAIN_H_
#define TOOLS_GN_TOOLCHAIN_H_
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "tools/gn/item.h"
#include "tools/gn/label_ptr.h"
#include "tools/gn/scope.h"
#include "tools/gn/source_file_type.h"
#include "tools/gn/substitution_type.h"
#include "tools/gn/tool.h"
#include "tools/gn/value.h"
// Holds information on a specific toolchain. This data is filled in when we
// encounter a toolchain definition.
//
// This class is an Item so it can participate in dependency management. In
// particular, when a target uses a toolchain, it should have a dependency on
// that toolchain's object so that we can be sure we loaded the toolchain
// before generating the build for that target.
//
// Note on threadsafety: The label of the toolchain never changes so can
// safely be accessed from any thread at any time (we do this when asking for
// the toolchain name). But the values in the toolchain do, so these can't
// be accessed until this Item is resolved.
class Toolchain : public Item {
public:
enum ToolType {
TYPE_NONE = 0,
TYPE_CC,
TYPE_CXX,
TYPE_OBJC,
TYPE_OBJCXX,
TYPE_RC,
TYPE_ASM,
TYPE_ALINK,
TYPE_SOLINK,
TYPE_LINK,
TYPE_STAMP,
TYPE_COPY,
TYPE_NUMTYPES // Must be last.
};
static const char* kToolCc;
static const char* kToolCxx;
static const char* kToolObjC;
static const char* kToolObjCxx;
static const char* kToolRc;
static const char* kToolAsm;
static const char* kToolAlink;
static const char* kToolSolink;
static const char* kToolLink;
static const char* kToolStamp;
static const char* kToolCopy;
Toolchain(const Settings* settings, const Label& label);
~Toolchain() override;
// Item overrides.
Toolchain* AsToolchain() override;
const Toolchain* AsToolchain() const override;
// Returns TYPE_NONE on failure.
static ToolType ToolNameToType(const base::StringPiece& str);
static std::string ToolTypeToName(ToolType type);
// Returns null if the tool hasn't been defined.
const Tool* GetTool(ToolType type) const;
// Set a tool. When all tools are configured, you should call
// ToolchainSetupComplete().
void SetTool(ToolType type, scoped_ptr<Tool> t);
// Does final setup on the toolchain once all tools are known.
void ToolchainSetupComplete();
// Targets that must be resolved before compiling any targets.
const LabelTargetVector& deps() const { return deps_; }
LabelTargetVector& deps() { return deps_; }
// Specifies build argument overrides that will be set on the base scope. It
// will be as if these arguments were passed in on the command line. This
// allows a toolchain to override the OS type of the default toolchain or
// pass in other settings.
Scope::KeyValueMap& args() { return args_; }
const Scope::KeyValueMap& args() const { return args_; }
// Returns the tool for compiling the given source file type.
static ToolType GetToolTypeForSourceType(SourceFileType type);
const Tool* GetToolForSourceType(SourceFileType type);
// Returns the tool that produces the final output for the given target type.
// This isn't necessarily the tool you would expect. For copy target, this
// will return the stamp tool ionstead since the final output of a copy
// target is to stamp the set of copies done so there is one output.
static ToolType GetToolTypeForTargetFinalOutput(const Target* target);
const Tool* GetToolForTargetFinalOutput(const Target* target) const;
const SubstitutionBits& substitution_bits() const {
DCHECK(setup_complete_);
return substitution_bits_;
}
void set_concurrent_links(int cl) { concurrent_links_ = cl; }
int concurrent_links() const { return concurrent_links_; }
private:
scoped_ptr<Tool> tools_[TYPE_NUMTYPES];
// How many links to run in parallel. Only the default toolchain's version of
// this variable applies.
int concurrent_links_;
bool setup_complete_;
// Substitutions used by the tools in this toolchain.
SubstitutionBits substitution_bits_;
LabelTargetVector deps_;
Scope::KeyValueMap args_;
};
#endif // TOOLS_GN_TOOLCHAIN_H_
|
