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
130
|
// 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/compiler_specific.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);
virtual ~Toolchain();
// Item overrides.
virtual Toolchain* AsToolchain() OVERRIDE;
virtual 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_
|
