1 /*
2 * Copyright (c) 1998, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "ci/ciMethod.hpp"
27 #include "ci/ciUtilities.hpp"
28 #include "compiler/abstractCompiler.hpp"
29 #include "compiler/compilerDirectives.hpp"
30 #include "compiler/compilerOracle.hpp"
31
32 CompilerDirectives::CompilerDirectives() :_match(NULL), _next(NULL), _ref_count(0) {
33 _c1_store = new DirectiveSet(this);
34 _c2_store = new DirectiveSet(this);
35 };
36
37 CompilerDirectives::~CompilerDirectives() {
38 if (_c1_store != NULL) {
39 delete _c1_store;
40 }
41 if (_c2_store != NULL) {
42 delete _c2_store;
43 }
44
45 // remove all linked method matchers
46 BasicMatcher* tmp = _match;
47 while (tmp != NULL) {
48 BasicMatcher* next = tmp->next();
49 delete tmp;
50 tmp = next;
51 }
52 }
53
54 void CompilerDirectives::print(outputStream* st) {
55 assert(DirectivesStack_lock->owned_by_self(), "");
56 if (_match != NULL) {
57 st->cr();
58 st->print("Directive:");
59 if (is_default_directive()) {
60 st->print_cr(" (default)");
61 } else {
62 st->cr();
63 }
64 st->print(" matching: ");
65 _match->print(st);
66 BasicMatcher* tmp = _match->next();
67 while (tmp != NULL) {
68 st->print(", ");
69 tmp->print(st);
70 tmp = tmp->next();
71 }
72 st->cr();
73 } else {
74 assert(0, "There should always be a match");
75 }
76
77 if (_c1_store != NULL) {
78 st->print_cr(" c1 directives:");
79 _c1_store->print(st);
80 }
81 if (_c2_store != NULL) {
82 st->cr();
83 st->print_cr(" c2 directives:");
84 _c2_store->print(st);
85 }
86 //---
87 }
88
89 void CompilerDirectives::finalize() {
90 if (_c1_store != NULL) {
91 _c1_store->finalize();
92 }
93 if (_c2_store != NULL) {
94 _c2_store->finalize();
95 }
96 }
97
98 void DirectiveSet::finalize() {
99 // if any flag has been modified - set directive as enabled
100 // unless it already has been explicitly set.
101 if (!_modified[EnableIndex]) {
102 if (_inlinematchers != NULL) {
103 EnableOption = true;
104 return;
105 }
106 int i;
107 for (i = 0; i < number_of_flags; i++) {
108 if (_modified[i]) {
109 EnableOption = true;
110 return;
111 }
112 }
113 }
114 }
115
116 CompilerDirectives* CompilerDirectives::next() {
117 return _next;
118 }
119
120 bool CompilerDirectives::match(methodHandle method) {
121 if (is_default_directive()) {
122 return true;
123 }
124 if (method == NULL) {
125 return false;
126 }
127 if (_match->match(method)) {
128 return true;
129 }
130 return false;
131 }
132
133 bool CompilerDirectives::add_match(char* str, const char*& error_msg) {
134 BasicMatcher* bm = BasicMatcher::parse_method_pattern(str, error_msg);
135 if (bm == NULL) {
136 assert(error_msg != NULL, "Must have error message");
137 return false;
138 } else {
139 bm->set_next(_match);
140 _match = bm;
141 return true;
142 }
143 }
144
145 void CompilerDirectives::inc_refcount() {
146 assert(DirectivesStack_lock->owned_by_self(), "");
147 _ref_count++;
148 }
149
150 void CompilerDirectives::dec_refcount() {
151 assert(DirectivesStack_lock->owned_by_self(), "");
152 _ref_count--;
153 }
154
155 int CompilerDirectives::refcount() {
156 assert(DirectivesStack_lock->owned_by_self(), "");
157 return _ref_count;
158 }
159
160 DirectiveSet* CompilerDirectives::get_for(AbstractCompiler *comp) {
161 assert(DirectivesStack_lock->owned_by_self(), "");
162 inc_refcount(); // The compiling thread is responsible to decrement this when finished.
163 if (comp == NULL) { // Xint
164 return _c1_store;
165 } else if (comp->is_c2()) {
166 return _c2_store;
167 } else if (comp->is_c1()) {
168 return _c1_store;
169 } else if (comp->is_shark()) {
170 return NULL;
171 } else if (comp->is_jvmci()) {
172 return NULL;
173 }
174 ShouldNotReachHere();
175 return NULL;
176 }
177
178 DirectiveSet::DirectiveSet(CompilerDirectives* d) :_inlinematchers(NULL), _directive(d) {
179 #define init_defaults_definition(name, type, dvalue, compiler) this->name##Option = dvalue;
180 compilerdirectives_common_flags(init_defaults_definition)
181 compilerdirectives_c2_flags(init_defaults_definition)
182 compilerdirectives_c1_flags(init_defaults_definition)
183 memset(_modified, 0, sizeof _modified);
184 }
185
186 DirectiveSet::~DirectiveSet() {
187 // remove all linked methodmatchers
188 InlineMatcher* tmp = _inlinematchers;
189 while (tmp != NULL) {
190 InlineMatcher* next = tmp->next();
191 delete tmp;
192 tmp = next;
193 }
194
195 // Free if modified, otherwise it just points to the global vm flag value
196 // or to the Compile command option
197 if (_modified[DisableIntrinsicIndex]) {
198 assert(this->DisableIntrinsicOption != NULL, "");
199 FREE_C_HEAP_ARRAY(char, (void *)this->DisableIntrinsicOption);
200 }
201 }
202
203 // Backward compatibility for CompileCommands
204 // Breaks the abstraction and causes lots of extra complexity
205 // - if some option is changed we need to copy directiveset since it no longer can be shared
206 // - Need to free copy after use
207 // - Requires a modified bit so we don't overwrite options that is set by directives
208
209 DirectiveSet* DirectiveSet::compilecommand_compatibility_init(methodHandle method) {
210 // Early bail out - checking all options is expensive - we rely on them not being used
211 // Only set a flag if it has not been modified and value changes.
212 // Only copy set if a flag needs to be set
213 if (!CompilerDirectivesIgnoreCompileCommandsOption && CompilerOracle::has_any_option()) {
214 DirectiveSet* set = DirectiveSet::clone(this);
215
216 bool changed = false; // Track if we actually change anything
217
218 // All CompileCommands are not equal so this gets a bit verbose
219 // When CompileCommands have been refactored less clutter will remain.
220 if (CompilerOracle::should_break_at(method)) {
221 if (!_modified[BreakAtCompileIndex]) {
222 set->BreakAtCompileOption = true;
223 changed = true;
224 }
225 if (!_modified[BreakAtExecuteIndex]) {
226 set->BreakAtExecuteOption = true;
227 changed = true;
228 }
229 }
230 if (CompilerOracle::should_log(method)) {
231 if (!_modified[LogIndex]) {
232 set->LogOption = true;
233 changed = true;
234 }
235 }
236 if (CompilerOracle::should_print(method)) {
237 if (!_modified[PrintAssemblyIndex]) {
238 set->PrintAssemblyOption = true;
239 changed = true;
240 }
241 }
242 // Exclude as in should not compile == Enabled
243 if (CompilerOracle::should_exclude(method)) {
244 if (!_modified[ExcludeIndex]) {
245 set->ExcludeOption = true;
246 changed = true;
247 }
248 }
249
250 // inline and dontinline (including exclude) are implemented in the directiveset accessors
251 #define init_default_cc(name, type, dvalue, cc_flag) { type v; if (!_modified[name##Index] && CompilerOracle::has_option_value(method, #cc_flag, v) && v != this->name##Option) { set->name##Option = v; changed = true;} }
252 compilerdirectives_common_flags(init_default_cc)
253 compilerdirectives_c2_flags(init_default_cc)
254 compilerdirectives_c1_flags(init_default_cc)
255
256 if (!changed) {
257 // We didn't actually update anything, discard.
258 delete set;
259 } else {
260 // We are returning a (parentless) copy. The originals parent don't need to account for this.
261 DirectivesStack::release(this);
262 return set;
263 }
264 }
265 // Nothing changed
266 return this;
267 }
268
269 CompilerDirectives* DirectiveSet::directive() {
270 assert(_directive != NULL, "Must have been initialized");
271 return _directive;
272 }
273
274 bool DirectiveSet::matches_inline(methodHandle method, int inline_action) {
275 if (_inlinematchers != NULL) {
276 if (_inlinematchers->match(method, InlineMatcher::force_inline)) {
277 return true;
278 }
279 }
280 return false;
281 }
282
283 bool DirectiveSet::should_inline(ciMethod* inlinee) {
284 inlinee->check_is_loaded();
285 VM_ENTRY_MARK;
286 methodHandle mh(THREAD, inlinee->get_Method());
287
288 if (matches_inline(mh, InlineMatcher::force_inline)) {
289 return true;
290 }
291 if (!CompilerDirectivesIgnoreCompileCommandsOption && CompilerOracle::should_inline(mh)) {
292 return true;
293 }
294 return false;
295 }
296
297 bool DirectiveSet::should_not_inline(ciMethod* inlinee) {
298 inlinee->check_is_loaded();
299 VM_ENTRY_MARK;
300 methodHandle mh(THREAD, inlinee->get_Method());
301
302 if (matches_inline(mh, InlineMatcher::dont_inline)) {
303 return true;
304 }
305 if (!CompilerDirectivesIgnoreCompileCommandsOption && CompilerOracle::should_not_inline(mh)) {
306 return true;
307 }
308 return false;
309 }
310
311 bool DirectiveSet::parse_and_add_inline(char* str, const char*& error_msg) {
312 InlineMatcher* m = InlineMatcher::parse_inline_pattern(str, error_msg);
313 if (m != NULL) {
314 // add matcher last in chain - the order is significant
315 append_inline(m);
316 return true;
317 } else {
318 assert(error_msg != NULL, "Error message must be set");
319 return false;
320 }
321 }
322
323 void DirectiveSet::append_inline(InlineMatcher* m) {
324 if (_inlinematchers == NULL) {
325 _inlinematchers = m;
326 return;
327 }
328 InlineMatcher* tmp = _inlinematchers;
329 while (tmp->next() != NULL) {
330 tmp = tmp->next();
331 }
332 tmp->set_next(m);
333 }
334
335 void DirectiveSet::print_inline(outputStream* st) {
336 if (_inlinematchers == NULL) {
337 st->print_cr(" inline: -");
338 } else {
339 st->print(" inline: ");
340 _inlinematchers->print(st);
341 InlineMatcher* tmp = _inlinematchers->next();
342 while (tmp != NULL) {
343 st->print(", ");
344 tmp->print(st);
345 tmp = tmp->next();
346 }
347 st->cr();
348 }
349 }
350
351 bool DirectiveSet::is_intrinsic_disabled(methodHandle method) {
352 vmIntrinsics::ID id = method->intrinsic_id();
353 assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
354
355 ccstr disable_intr = DisableIntrinsicOption;
356 return ((disable_intr != '\0') && strstr(disable_intr, vmIntrinsics::name_at(id)) != NULL);
357 }
358
359 DirectiveSet* DirectiveSet::clone(DirectiveSet const* src) {
360 DirectiveSet* set = new DirectiveSet(NULL);
361 memcpy(set->_modified, src->_modified, sizeof(src->_modified));
362
363 InlineMatcher* tmp = src->_inlinematchers;
364 while (tmp != NULL) {
365 set->append_inline(tmp->clone());
366 tmp = tmp->next();
367 }
368
369 #define copy_members_definition(name, type, dvalue, cc_flag) set->name##Option = src->name##Option;
370 compilerdirectives_common_flags(copy_members_definition)
371 compilerdirectives_c2_flags(copy_members_definition)
372 compilerdirectives_c1_flags(copy_members_definition)
373
374 // Must duplicate ccstr option if it was modified, otherwise it is global.
375 if (src->_modified[DisableIntrinsicIndex]) {
376 assert(src->DisableIntrinsicOption != NULL, "");
377 size_t len = strlen(src->DisableIntrinsicOption) + 1;
378 char* s = NEW_C_HEAP_ARRAY(char, len, mtCompiler);
379 strncpy(s, src->DisableIntrinsicOption, len);
380 assert(s[len-1] == '\0', "");
381 set->DisableIntrinsicOption = s;
382 }
383 return set;
384 }
385
386 // Create a new dirstack and push a default directive
387 void DirectivesStack::init() {
388 CompilerDirectives* _default_directives = new CompilerDirectives();
389 char str[] = "*.*";
390 const char* error_msg = NULL;
391 _default_directives->add_match(str, error_msg);
392 #ifdef COMPILER1
393 _default_directives->_c1_store->EnableOption = true;
394 #endif
395 #ifdef COMPILER2
396 _default_directives->_c2_store->EnableOption = true;
397 #endif
398 assert(error_msg == NULL, "Must succeed.");
399 push(_default_directives);
400 }
401
402 DirectiveSet* DirectivesStack::getDefaultDirective(AbstractCompiler* comp) {
403 MutexLockerEx locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);
404
405 assert(_bottom != NULL, "Must never be empty");
406 return _bottom->get_for(comp);
407 }
408
409 void DirectivesStack::push(CompilerDirectives* directive) {
410 MutexLockerEx locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);
411
412 directive->inc_refcount();
413 if (_top == NULL) {
414 assert(_bottom == NULL, "There can only be one default directive");
415 _bottom = directive; // default directive, can never be removed.
416 }
417
418 directive->set_next(_top);
419 _top = directive;
420 _depth++;
421 }
422
423 void DirectivesStack::pop() {
424 MutexLockerEx locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);
425 pop_inner();
426 }
427
428 void DirectivesStack::pop_inner() {
429 assert(DirectivesStack_lock->owned_by_self(), "");
430
431 if (_top->next() == NULL) {
432 return; // Do nothing - don't allow an empty stack
433 }
434 CompilerDirectives* tmp = _top;
435 _top = _top->next();
436 _depth--;
437
438 DirectivesStack::release(tmp);
439 }
440
441 void DirectivesStack::clear() {
442 // holding the lock during the whole operation ensuring consistent result
443 MutexLockerEx locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);
444 while (_top->next() != NULL) {
445 pop_inner();
446 }
447 }
448
449 void DirectivesStack::print(outputStream* st) {
450 MutexLockerEx locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);
451 CompilerDirectives* tmp = _top;
452 while (tmp != NULL) {
453 tmp->print(st);
454 tmp = tmp->next();
455 st->cr();
456 }
457 }
458
459 void DirectivesStack::release(DirectiveSet* set) {
460 MutexLockerEx locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);
461 if (set->is_exclusive_copy()) {
462 // Old CompilecCmmands forced us to create an exclusive copy
463 delete set;
464 } else {
465 assert(set->directive() != NULL, "");
466 release(set->directive());
467 }
468 }
469
470
471 void DirectivesStack::release(CompilerDirectives* dir) {
472 assert(DirectivesStack_lock->owned_by_self(), "");
473 dir->dec_refcount();
474 if (dir->refcount() == 0) {
475 delete dir;
476 }
477 }
478
479 DirectiveSet* DirectivesStack::getMatchingDirective(methodHandle method, AbstractCompiler *comp) {
480 assert(_depth > 0, "Must never be empty");
481 CompilerDirectives* dir = _top;
482 assert(dir != NULL, "Must be initialized");
483
484 DirectiveSet* match = NULL;
485 {
486 MutexLockerEx locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);
487 while (dir != NULL) {
488 if (dir->is_default_directive() || dir->match(method)) {
489 match = dir->get_for(comp);
490 if (match->EnableOption) {
491 // The directiveSet for this compile is also enabled -> success
492 break;
493 }
494 }
495 dir = dir->next();
496 }
497 }
498
499 guarantee(match != NULL, "There should always be a default directive that matches");
500 // Check for legacy compile commands update, without DirectivesStack_lock
501 return match->compilecommand_compatibility_init(method);
502 }