1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <chrono>
17 #include <iostream>
18 #include <csignal> // NOLINTNEXTLINE(modernize-deprecated-headers)
19 #include <vector>
20
21 #include "ecmascript/compiler/jit_compiler.h"
22 #include "ecmascript/compiler/baseline/baseline_compiler.h"
23
24 #include "ecmascript/jit/jit_task.h"
25 #include "ecmascript/log.h"
26 #include "ecmascript/napi/include/jsnapi.h"
27 #include "ecmascript/platform/file.h"
28
29 namespace panda::ecmascript::kungfu {
GetInstance(JSRuntimeOptions * options)30 JitCompiler *JitCompiler::GetInstance(JSRuntimeOptions *options)
31 {
32 static JitCompiler instance(options);
33 return &instance;
34 }
35
UpdatePassOptions(CompilationEnv * env)36 void JitCompiler::UpdatePassOptions(CompilationEnv *env)
37 {
38 ASSERT(env != nullptr);
39 EcmaVM *vm = env->GetHostThread()->GetEcmaVM();
40 bool builtinsLazyEnabled = vm->GetJSOptions().IsWorker() && vm->GetJSOptions().GetEnableBuiltinsLazy();
41 if (builtinsLazyEnabled) {
42 passOptions_.SetLoweringBuiltin(false);
43 }
44 }
45
JitCompilationOptions(JSRuntimeOptions runtimeOptions)46 JitCompilationOptions::JitCompilationOptions(JSRuntimeOptions runtimeOptions)
47 {
48 #if defined(PANDA_TARGET_AMD64)
49 triple_ = TARGET_X64;
50 #elif defined(PANDA_TARGET_ARM64)
51 triple_ = TARGET_AARCH64;
52 #else
53 LOG_JIT(FATAL) << "jit unsupport arch";
54 UNREACHABLE();
55 #endif
56 // refactor: remove JitCompilationOptions, reuse CompilationOptions
57 optLevel_ = runtimeOptions.GetOptLevel();
58 relocMode_ = runtimeOptions.GetRelocMode();
59 logOption_ = runtimeOptions.GetCompilerLogOption();
60 logMethodsList_ = runtimeOptions.GetMethodsListForLog();
61 compilerLogTime_ = runtimeOptions.IsEnableCompilerLogTime();
62 deviceIsScreenOff_ = runtimeOptions.GetDeviceState();
63 deviceThermalLevel_ = runtimeOptions.GetThermalLevel();
64 hotnessThreshold_ = runtimeOptions.GetPGOHotnessThreshold();
65 profilerIn_ = std::string(runtimeOptions.GetPGOProfilerPath());
66 isEnableArrayBoundsCheckElimination_ = runtimeOptions.IsEnableArrayBoundsCheckElimination();
67 isEnableTypeLowering_ = (runtimeOptions.IsEnableTypeLowering()) && (!runtimeOptions.IsEnableJitFastCompile());
68 isEnableEarlyElimination_ = runtimeOptions.IsEnableEarlyElimination();
69 isEnableLaterElimination_ = runtimeOptions.IsEnableLaterElimination();
70 isEnableValueNumbering_ = runtimeOptions.IsEnableValueNumbering();
71 isEnableOptInlining_ = runtimeOptions.IsEnableAPPJIT() ? false : runtimeOptions.IsEnableOptInlining();
72 isEnableOptString_ = runtimeOptions.IsEnableOptString();
73 isEnableOptPGOType_ = runtimeOptions.IsEnableOptPGOType();
74 isEnableOptTrackField_ = runtimeOptions.IsEnableOptTrackField();
75 isEnableOptLoopPeeling_ = runtimeOptions.IsEnableOptLoopPeeling();
76 isEnableOptOnHeapCheck_ = runtimeOptions.IsEnableOptOnHeapCheck();
77 isEnableOptLoopInvariantCodeMotion_ = runtimeOptions.IsEnableOptLoopInvariantCodeMotion();
78 isEnableOptConstantFolding_ = runtimeOptions.IsEnableOptConstantFolding();
79 isEnableLexenvSpecialization_ = runtimeOptions.IsEnableLexenvSpecialization();
80 isEnableNativeInline_ = runtimeOptions.IsEnableNativeInline();
81 isEnableLoweringBuiltin_ = runtimeOptions.IsEnableLoweringBuiltin();
82 }
83
Init(JSRuntimeOptions runtimeOptions)84 void JitCompiler::Init(JSRuntimeOptions runtimeOptions)
85 {
86 BytecodeStubCSigns::Initialize();
87 CommonStubCSigns::Initialize();
88 BuiltinsStubCSigns::Initialize();
89 RuntimeStubCSigns::Initialize();
90
91 JitCompilationOptions jitOptions(runtimeOptions);
92 jitOptions_ = jitOptions;
93 PassOptions::Builder optionsBuilder;
94 passOptions_ =
95 optionsBuilder.EnableArrayBoundsCheckElimination(jitOptions_.isEnableArrayBoundsCheckElimination_)
96 .EnableTypeLowering(jitOptions_.isEnableTypeLowering_)
97 .EnableEarlyElimination(jitOptions_.isEnableEarlyElimination_)
98 .EnableLaterElimination(jitOptions_.isEnableLaterElimination_)
99 .EnableValueNumbering(jitOptions_.isEnableValueNumbering_)
100 .EnableOptInlining(jitOptions_.isEnableOptInlining_)
101 .EnableOptString(jitOptions_.isEnableOptString_)
102 .EnableOptPGOType(jitOptions_.isEnableOptPGOType_)
103 .EnableOptTrackField(jitOptions_.isEnableOptTrackField_)
104 .EnableOptLoopPeeling(jitOptions_.isEnableOptLoopPeeling_)
105 .EnableOptLoopInvariantCodeMotion(jitOptions_.isEnableOptLoopInvariantCodeMotion_)
106 .EnableOptConstantFolding(jitOptions_.isEnableOptConstantFolding_)
107 .EnableLexenvSpecialization(jitOptions_.isEnableLexenvSpecialization_)
108 .EnableInlineNative(jitOptions_.isEnableNativeInline_)
109 .EnableLoweringBuiltin(jitOptions_.isEnableLoweringBuiltin_)
110 .Build();
111 }
112
CreateJitCompilerTask(JitTask * jitTask)113 JitCompilerTask *JitCompilerTask::CreateJitCompilerTask(JitTask *jitTask)
114 {
115 return new (std::nothrow) JitCompilerTask(jitTask);
116 }
117
Compile()118 bool JitCompilerTask::Compile()
119 {
120 if (compilerTier_ == CompilerTier::BASELINE) {
121 auto baselineCompiler = new (std::nothrow) BaselineCompiler(jitCompilationEnv_->GetHostThread()->GetEcmaVM(),
122 jitCompilationEnv_.get());
123 if (baselineCompiler == nullptr) {
124 return false;
125 }
126 baselineCompiler_.reset(baselineCompiler);
127 baselineCompiler_->Compile(jitCompilationEnv_->GetJSPandaFile(), jitCompilationEnv_->GetMethodLiteral());
128 return true;
129 }
130
131 JitCompiler *jitCompiler = JitCompiler::GetInstance();
132 jitCompiler->UpdatePassOptions(jitCompilationEnv_.get());
133 auto jitPassManager = new (std::nothrow) JitPassManager(jitCompilationEnv_.get(),
134 jitCompiler->GetJitOptions().triple_,
135 jitCompiler->GetJitOptions().optLevel_,
136 jitCompiler->GetJitOptions().relocMode_,
137 &jitCompiler->GetCompilerLog(),
138 &jitCompiler->GetLogList(),
139 jitCompiler->GetProfilerDecoder(),
140 &jitCompiler->GetPassOptions());
141 if (jitPassManager == nullptr) {
142 return false;
143 }
144 passManager_.reset(jitPassManager);
145 auto aotFileGenerator = new (std::nothrow) AOTFileGenerator(&jitCompiler->GetCompilerLog(),
146 &jitCompiler->GetLogList(), jitCompilationEnv_.get(),
147 jitCompiler->GetJitOptions().triple_, jitCompilationEnv_->GetJSOptions().IsCompilerEnableLiteCG());
148 if (aotFileGenerator == nullptr) {
149 return false;
150 }
151 jitCodeGenerator_.reset(aotFileGenerator);
152 return passManager_->Compile(profileTypeInfo_, *jitCodeGenerator_, offset_);
153 }
154
ReleaseJitPassManager()155 void JitCompilerTask::ReleaseJitPassManager()
156 {
157 // release passManager before jitCompilerTask release,
158 // in future release JitCompilerTask when compile finish
159 JitPassManager *passManager = passManager_.release();
160 delete passManager;
161 }
162
Finalize(JitTask * jitTask)163 bool JitCompilerTask::Finalize(JitTask *jitTask)
164 {
165 if (jitTask == nullptr) {
166 return false;
167 }
168 if (compilerTier_ == CompilerTier::BASELINE) {
169 return baselineCompiler_->CollectMemoryCodeInfos(jitTask->GetMachineCodeDesc());
170 }
171 jitCodeGenerator_->JitCreateLitecgModule();
172 bool result = true;
173 result &= passManager_->RunCg();
174 result &= jitCodeGenerator_->GetMemoryCodeInfos(jitTask->GetMachineCodeDesc());
175 ReleaseJitPassManager();
176 return result;
177 }
178
179
CopyCodeToFort(MachineCodeDesc & desc)180 static ARK_INLINE bool CopyCodeToFort(MachineCodeDesc &desc)
181 {
182 uint8_t *pText = reinterpret_cast<uint8_t*>(desc.instructionsAddr);
183 if (desc.rodataSizeBeforeTextAlign != 0) {
184 pText += desc.rodataSizeBeforeTextAlign;
185 }
186 #ifdef JIT_ENABLE_CODE_SIGN
187 if ((uintptr_t)desc.codeSigner == 0) {
188 if (memcpy_s(pText, desc.codeSizeAlign, reinterpret_cast<uint8_t*>(desc.codeAddr), desc.codeSize) != EOK) {
189 LOG_JIT(ERROR) << "memcpy failed in CopyToCache";
190 return false;
191 }
192 } else {
193 LOG_JIT(DEBUG) << "Copy: "
194 << std::hex << (uintptr_t)pText << " <- "
195 << std::hex << (uintptr_t)desc.codeAddr << " size: " << desc.codeSize;
196 LOG_JIT(DEBUG) << " codeSigner = " << std::hex << (uintptr_t)desc.codeSigner;
197 OHOS::Security::CodeSign::JitCodeSignerBase *signer =
198 reinterpret_cast<OHOS::Security::CodeSign::JitCodeSignerBase*>(desc.codeSigner);
199 int err = OHOS::Security::CodeSign::CopyToJitCode(
200 signer, pText, reinterpret_cast<void *>(desc.codeAddr), desc.codeSize);
201 if (err != EOK) {
202 LOG_JIT(ERROR) << " CopyToJitCode failed, err: " << err;
203 return false;
204 } else {
205 LOG_JIT(DEBUG) << " CopyToJitCode success!!";
206 }
207 delete reinterpret_cast<OHOS::Security::CodeSign::JitCodeSignerBase*>(desc.codeSigner);
208 }
209 #else
210 if (memcpy_s(pText, desc.codeSizeAlign, reinterpret_cast<uint8_t*>(desc.codeAddr), desc.codeSize) != EOK) {
211 LOG_JIT(ERROR) << "memcpy failed in CopyToCache";
212 return false;
213 }
214 #endif
215 return true;
216 }
217
AllocFromFortAndCopy(CompilationEnv & compilationEnv,MachineCodeDesc & desc)218 ARK_INLINE bool JitCompiler::AllocFromFortAndCopy(CompilationEnv &compilationEnv, MachineCodeDesc &desc)
219 {
220 ASSERT(compilationEnv.IsJitCompiler());
221 JSThread *hostThread = static_cast<JitCompilationEnv&>(compilationEnv).GetHostThread();
222 Jit::JitGCLockHolder lock(hostThread);
223
224 size_t size = JitTask::ComputePayLoadSize(desc);
225 const Heap *heap = hostThread->GetEcmaVM()->GetHeap();
226
227 if (desc.isHugeObj) {
228 Region *region = heap->GetHugeMachineCodeSpace()->AllocateFort(
229 size + MachineCode::SIZE, hostThread, &desc);
230 if (!region || !desc.instructionsAddr) {
231 return false;
232 }
233 desc.hugeObjRegion = ToUintPtr(region);
234 } else {
235 uintptr_t mem = heap->GetMachineCodeSpace()->JitFortAllocate(&desc);
236 if (mem == ToUintPtr(nullptr)) {
237 return false;
238 }
239 desc.instructionsAddr = mem;
240 }
241
242 if (!CopyCodeToFort(desc)) {
243 return false;
244 }
245 return true;
246 }
247
InitJitCompiler(JSRuntimeOptions options)248 void InitJitCompiler(JSRuntimeOptions options)
249 {
250 JitCompiler *jitCompiler = JitCompiler::GetInstance(&options);
251 jitCompiler->Init(options);
252 }
253
CreateJitCompilerTask(JitTask * jitTask)254 void *CreateJitCompilerTask(JitTask *jitTask)
255 {
256 if (jitTask == nullptr) {
257 return nullptr;
258 }
259 return JitCompilerTask::CreateJitCompilerTask(jitTask);
260 }
261
JitCompile(void * compilerTask,JitTask * jitTask)262 bool JitCompile(void *compilerTask, JitTask *jitTask)
263 {
264 if (jitTask == nullptr || compilerTask == nullptr) {
265 return false;
266 }
267 auto jitCompilerTask = reinterpret_cast<JitCompilerTask*>(compilerTask);
268 return jitCompilerTask->Compile();
269 }
270
JitFinalize(void * compilerTask,JitTask * jitTask)271 bool JitFinalize(void *compilerTask, JitTask *jitTask)
272 {
273 if (jitTask == nullptr || compilerTask == nullptr) {
274 return false;
275 }
276 auto jitCompilerTask = reinterpret_cast<JitCompilerTask*>(compilerTask);
277 return jitCompilerTask->Finalize(jitTask);
278 }
279
DeleteJitCompile(void * handle)280 void DeleteJitCompile(void *handle)
281 {
282 if (handle == nullptr) {
283 return;
284 }
285 delete reinterpret_cast<JitCompilerTask*>(handle);
286 }
287 } // namespace panda::ecmascript::kungfu
288