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 "art_method-inl.h"
18 #include "jit/jit.h"
19 #include "jit/jit_code_cache.h"
20 #include "jit/profiling_info.h"
21 #include "nativehelper/ScopedUtfChars.h"
22 #include "oat_quick_method_header.h"
23 #include "scoped_thread_state_change-inl.h"
24 #include "stack.h"
25 #include "stack_map.h"
26 
27 namespace art {
28 
29 class OsrVisitor : public StackVisitor {
30  public:
31   explicit OsrVisitor(Thread* thread, const char* method_name)
32       REQUIRES_SHARED(Locks::mutator_lock_)
33       : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
34         method_name_(method_name),
35         in_osr_method_(false),
36         in_interpreter_(false) {}
37 
38   bool VisitFrame() REQUIRES_SHARED(Locks::mutator_lock_) {
39     ArtMethod* m = GetMethod();
40     std::string m_name(m->GetName());
41 
42     if (m_name.compare(method_name_) == 0) {
43       const OatQuickMethodHeader* header =
44           Runtime::Current()->GetJit()->GetCodeCache()->LookupOsrMethodHeader(m);
45       if (header != nullptr && header == GetCurrentOatQuickMethodHeader()) {
46         in_osr_method_ = true;
47       } else if (IsShadowFrame()) {
48         in_interpreter_ = true;
49       }
50       return false;
51     }
52     return true;
53   }
54 
55   const char* const method_name_;
56   bool in_osr_method_;
57   bool in_interpreter_;
58 };
59 
60 extern "C" JNIEXPORT jboolean JNICALL Java_Main_isInOsrCode(JNIEnv* env,
61                                                             jclass,
62                                                             jstring method_name) {
63   jit::Jit* jit = Runtime::Current()->GetJit();
64   if (jit == nullptr) {
65     // Just return true for non-jit configurations to stop the infinite loop.
66     return JNI_TRUE;
67   }
68   ScopedUtfChars chars(env, method_name);
69   CHECK(chars.c_str() != nullptr);
70   ScopedObjectAccess soa(Thread::Current());
71   OsrVisitor visitor(soa.Self(), chars.c_str());
72   visitor.WalkStack();
73   return visitor.in_osr_method_;
74 }
75 
76 extern "C" JNIEXPORT jboolean JNICALL Java_Main_isInInterpreter(JNIEnv* env,
77                                                                 jclass,
78                                                                 jstring method_name) {
79   if (!Runtime::Current()->UseJitCompilation()) {
80     // The return value is irrelevant if we're not using JIT.
81     return false;
82   }
83   ScopedUtfChars chars(env, method_name);
84   CHECK(chars.c_str() != nullptr);
85   ScopedObjectAccess soa(Thread::Current());
86   OsrVisitor visitor(soa.Self(), chars.c_str());
87   visitor.WalkStack();
88   return visitor.in_interpreter_;
89 }
90 
91 class ProfilingInfoVisitor : public StackVisitor {
92  public:
93   explicit ProfilingInfoVisitor(Thread* thread, const char* method_name)
94       REQUIRES_SHARED(Locks::mutator_lock_)
95       : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
96         method_name_(method_name) {}
97 
98   bool VisitFrame() REQUIRES_SHARED(Locks::mutator_lock_) {
99     ArtMethod* m = GetMethod();
100     std::string m_name(m->GetName());
101 
102     if (m_name.compare(method_name_) == 0) {
103       ProfilingInfo::Create(Thread::Current(), m, /* retry_allocation */ true);
104       return false;
105     }
106     return true;
107   }
108 
109   const char* const method_name_;
110 };
111 
112 extern "C" JNIEXPORT void JNICALL Java_Main_ensureHasProfilingInfo(JNIEnv* env,
113                                                                    jclass,
114                                                                    jstring method_name) {
115   if (!Runtime::Current()->UseJitCompilation()) {
116     return;
117   }
118   ScopedUtfChars chars(env, method_name);
119   CHECK(chars.c_str() != nullptr);
120   ScopedObjectAccess soa(Thread::Current());
121   ProfilingInfoVisitor visitor(soa.Self(), chars.c_str());
122   visitor.WalkStack();
123 }
124 
125 class OsrCheckVisitor : public StackVisitor {
126  public:
127   OsrCheckVisitor(Thread* thread, const char* method_name)
128       REQUIRES_SHARED(Locks::mutator_lock_)
129       : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
130         method_name_(method_name) {}
131 
132   bool VisitFrame() REQUIRES_SHARED(Locks::mutator_lock_) {
133     ArtMethod* m = GetMethod();
134     std::string m_name(m->GetName());
135 
136     jit::Jit* jit = Runtime::Current()->GetJit();
137     if (m_name.compare(method_name_) == 0) {
138       while (jit->GetCodeCache()->LookupOsrMethodHeader(m) == nullptr) {
139         // Sleep to yield to the compiler thread.
140         usleep(1000);
141         // Will either ensure it's compiled or do the compilation itself.
142         jit->CompileMethod(m, Thread::Current(), /* osr */ true);
143       }
144       return false;
145     }
146     return true;
147   }
148 
149   const char* const method_name_;
150 };
151 
152 extern "C" JNIEXPORT void JNICALL Java_Main_ensureHasOsrCode(JNIEnv* env,
153                                                              jclass,
154                                                              jstring method_name) {
155   if (!Runtime::Current()->UseJitCompilation()) {
156     return;
157   }
158   ScopedUtfChars chars(env, method_name);
159   CHECK(chars.c_str() != nullptr);
160   ScopedObjectAccess soa(Thread::Current());
161   OsrCheckVisitor visitor(soa.Self(), chars.c_str());
162   visitor.WalkStack();
163 }
164 
165 }  // namespace art
166