blob: 8762b53af46fe08d5726413a48adff76ff42eabe (
plain)
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
131
132
133
134
135
136
137
138
139
140
|
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ART_COMPILER_DEX_PASS_DRIVER_H_
#define ART_COMPILER_DEX_PASS_DRIVER_H_
#include <vector>
#include "base/logging.h"
#include "pass.h"
#include "pass_manager.h"
namespace art {
class Pass;
class PassDataHolder;
class PassDriver;
class PassManager;
// Empty holder for the constructor.
class PassDriverDataHolder {
};
/**
* @class PassDriver
* @brief PassDriver is the wrapper around all Pass instances in order to execute them
*/
class PassDriver {
public:
explicit PassDriver(const PassManager* const pass_manager) : pass_manager_(pass_manager) {
pass_list_ = *pass_manager_->GetDefaultPassList();
DCHECK(!pass_list_.empty());
}
virtual ~PassDriver() {
}
/**
* @brief Insert a Pass: can warn if multiple passes have the same name.
*/
void InsertPass(const Pass* new_pass) {
DCHECK(new_pass != nullptr);
DCHECK(new_pass->GetName() != nullptr);
DCHECK_NE(new_pass->GetName()[0], 0);
// It is an error to override an existing pass.
DCHECK(GetPass(new_pass->GetName()) == nullptr)
<< "Pass name " << new_pass->GetName() << " already used.";
// Now add to the list.
pass_list_.push_back(new_pass);
}
/**
* @brief Run a pass using the name as key.
* @return whether the pass was applied.
*/
virtual bool RunPass(const char* pass_name) {
// Paranoid: c_unit cannot be null and we need a pass name.
DCHECK(pass_name != nullptr);
DCHECK_NE(pass_name[0], 0);
const Pass* cur_pass = GetPass(pass_name);
if (cur_pass != nullptr) {
return RunPass(cur_pass);
}
// Return false, we did not find the pass.
return false;
}
/**
* @brief Runs all the passes with the pass_list_.
*/
void Launch() {
for (const Pass* cur_pass : pass_list_) {
RunPass(cur_pass);
}
}
/**
* @brief Searches for a particular pass.
* @param the name of the pass to be searched for.
*/
const Pass* GetPass(const char* name) const {
for (const Pass* cur_pass : pass_list_) {
if (strcmp(name, cur_pass->GetName()) == 0) {
return cur_pass;
}
}
return nullptr;
}
/**
* @brief Run a pass using the Pass itself.
* @param time_split do we want a time split request(default: false)?
* @return whether the pass was applied.
*/
virtual bool RunPass(const Pass* pass, bool time_split = false) = 0;
protected:
/**
* @brief Apply a patch: perform start/work/end functions.
*/
virtual void ApplyPass(PassDataHolder* data, const Pass* pass) {
pass->Start(data);
DispatchPass(pass);
pass->End(data);
}
/**
* @brief Dispatch a patch.
* Gives the ability to add logic when running the patch.
*/
virtual void DispatchPass(const Pass* pass) {
UNUSED(pass);
}
/** @brief List of passes: provides the order to execute the passes.
* Passes are owned by pass_manager_. */
std::vector<const Pass*> pass_list_;
const PassManager* const pass_manager_;
};
} // namespace art
#endif // ART_COMPILER_DEX_PASS_DRIVER_H_
|
