1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "escape.h"
18
19 #include "nodes.h"
20
21 namespace art {
22
CalculateEscape(HInstruction * reference,bool (* no_escape)(HInstruction *,HInstruction *),bool * is_singleton,bool * is_singleton_and_not_returned,bool * is_singleton_and_not_deopt_visible)23 void CalculateEscape(HInstruction* reference,
24 bool (*no_escape)(HInstruction*, HInstruction*),
25 /*out*/ bool* is_singleton,
26 /*out*/ bool* is_singleton_and_not_returned,
27 /*out*/ bool* is_singleton_and_not_deopt_visible) {
28 // For references not allocated in the method, don't assume anything.
29 if (!reference->IsNewInstance() && !reference->IsNewArray()) {
30 *is_singleton = false;
31 *is_singleton_and_not_returned = false;
32 *is_singleton_and_not_deopt_visible = false;
33 return;
34 }
35 // Assume the best until proven otherwise.
36 *is_singleton = true;
37 *is_singleton_and_not_returned = true;
38 *is_singleton_and_not_deopt_visible = true;
39
40 if (reference->IsNewInstance() && reference->AsNewInstance()->IsFinalizable()) {
41 // Finalizable reference is treated as being returned in the end.
42 *is_singleton_and_not_returned = false;
43 }
44
45 // Visit all uses to determine if this reference can escape into the heap,
46 // a method call, an alias, etc.
47 for (const HUseListNode<HInstruction*>& use : reference->GetUses()) {
48 HInstruction* user = use.GetUser();
49 if (no_escape != nullptr && (*no_escape)(reference, user)) {
50 // Client supplied analysis says there is no escape.
51 continue;
52 } else if (user->IsBoundType() || user->IsNullCheck()) {
53 // BoundType shouldn't normally be necessary for an allocation. Just be conservative
54 // for the uncommon cases. Similarly, null checks are eventually eliminated for explicit
55 // allocations, but if we see one before it is simplified, assume an alias.
56 *is_singleton = false;
57 *is_singleton_and_not_returned = false;
58 *is_singleton_and_not_deopt_visible = false;
59 return;
60 } else if (user->IsPhi() ||
61 user->IsSelect() ||
62 (user->IsInvoke() && user->GetSideEffects().DoesAnyWrite()) ||
63 (user->IsInstanceFieldSet() && (reference == user->InputAt(1))) ||
64 (user->IsUnresolvedInstanceFieldSet() && (reference == user->InputAt(1))) ||
65 (user->IsStaticFieldSet() && (reference == user->InputAt(1))) ||
66 (user->IsUnresolvedStaticFieldSet() && (reference == user->InputAt(0))) ||
67 (user->IsArraySet() && (reference == user->InputAt(2)))) {
68 // The reference is merged to HPhi/HSelect, passed to a callee, or stored to heap.
69 // Hence, the reference is no longer the only name that can refer to its value.
70 *is_singleton = false;
71 *is_singleton_and_not_returned = false;
72 *is_singleton_and_not_deopt_visible = false;
73 return;
74 } else if ((user->IsUnresolvedInstanceFieldGet() && (reference == user->InputAt(0))) ||
75 (user->IsUnresolvedInstanceFieldSet() && (reference == user->InputAt(0)))) {
76 // The field is accessed in an unresolved way. We mark the object as a non-singleton.
77 // Note that we could optimize this case and still perform some optimizations until
78 // we hit the unresolved access, but the conservative assumption is the simplest.
79 *is_singleton = false;
80 *is_singleton_and_not_returned = false;
81 *is_singleton_and_not_deopt_visible = false;
82 return;
83 } else if (user->IsReturn()) {
84 *is_singleton_and_not_returned = false;
85 }
86 }
87
88 // Look at the environment uses if it's for HDeoptimize. Other environment uses are fine,
89 // as long as client optimizations that rely on this information are disabled for debuggable.
90 for (const HUseListNode<HEnvironment*>& use : reference->GetEnvUses()) {
91 HEnvironment* user = use.GetUser();
92 if (user->GetHolder()->IsDeoptimize()) {
93 *is_singleton_and_not_deopt_visible = false;
94 break;
95 }
96 }
97 }
98
DoesNotEscape(HInstruction * reference,bool (* no_escape)(HInstruction *,HInstruction *))99 bool DoesNotEscape(HInstruction* reference, bool (*no_escape)(HInstruction*, HInstruction*)) {
100 bool is_singleton = false;
101 bool is_singleton_and_not_returned = false;
102 bool is_singleton_and_not_deopt_visible = false; // not relevant for escape
103 CalculateEscape(reference,
104 no_escape,
105 &is_singleton,
106 &is_singleton_and_not_returned,
107 &is_singleton_and_not_deopt_visible);
108 return is_singleton_and_not_returned;
109 }
110
111 } // namespace art
112