blob: 2030db944f0c02aa59317805a15a660ecf136705 [file] [log] [blame]
Logancf3e5212010-12-29 01:44:55 +08001/*
2 * copyright 2010, 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
Logancf3e5212010-12-29 01:44:55 +080017#include "Script.h"
18
Logan35849002011-01-15 07:30:43 +080019#include "Config.h"
20
Logan Chiend2a5f302011-07-19 20:32:25 +080021#if USE_OLD_JIT
22#include "OldJIT/CacheReader.h"
23#include "OldJIT/CacheWriter.h"
24#endif
25
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -070026#include "MCCacheReader.h"
27#include "MCCacheWriter.h"
Zonr Chang2fcbd022012-01-06 21:04:31 +080028#include "CompilerOption.h"
Logan Chiend2a5f302011-07-19 20:32:25 +080029
30#if USE_OLD_JIT
31#include "OldJIT/ContextManager.h"
32#endif
33
Logan4dcd6792011-02-28 05:12:00 +080034#include "DebugHelper.h"
Logan04329712011-01-06 06:10:57 +080035#include "FileHandle.h"
Logancf3e5212010-12-29 01:44:55 +080036#include "ScriptCompiled.h"
Logan9a5f8682011-01-07 06:09:57 +080037#include "ScriptCached.h"
38#include "Sha1Helper.h"
Logan474cbd22011-01-31 01:47:44 +080039#include "SourceInfo.h"
Logancf3e5212010-12-29 01:44:55 +080040
Logan89eb47f2011-01-07 10:45:16 +080041#include <errno.h>
Logan474cbd22011-01-31 01:47:44 +080042#include <sys/stat.h>
43#include <sys/types.h>
Bhanu Chetlapallieb4509b2012-01-08 20:42:56 -080044#include <unistd.h>
Logancf3e5212010-12-29 01:44:55 +080045
Logan89eb47f2011-01-07 10:45:16 +080046#include <new>
47#include <string.h>
Logan033f46e2011-01-06 05:51:24 +080048#include <cutils/properties.h>
49
Logan89eb47f2011-01-07 10:45:16 +080050
Loganecf4cbd2011-01-06 05:34:11 +080051namespace {
52
Logan033f46e2011-01-06 05:51:24 +080053bool getBooleanProp(const char *str) {
Loganf340bf72011-01-14 17:51:40 +080054 char buf[PROPERTY_VALUE_MAX];
55 property_get(str, buf, "0");
56 return strcmp(buf, "0") != 0;
Logan033f46e2011-01-06 05:51:24 +080057}
58
Loganecf4cbd2011-01-06 05:34:11 +080059} // namespace anonymous
60
Logancf3e5212010-12-29 01:44:55 +080061namespace bcc {
62
63Script::~Script() {
Logan35849002011-01-15 07:30:43 +080064 switch (mStatus) {
65 case ScriptStatus::Compiled:
Logancf3e5212010-12-29 01:44:55 +080066 delete mCompiled;
Logan35849002011-01-15 07:30:43 +080067 break;
68
69#if USE_CACHE
70 case ScriptStatus::Cached:
Shih-wei Liaoc4cf6542011-01-13 01:43:01 -080071 delete mCached;
Logan35849002011-01-15 07:30:43 +080072 break;
73#endif
74
75 default:
76 break;
Logancf3e5212010-12-29 01:44:55 +080077 }
Logan474cbd22011-01-31 01:47:44 +080078
Shih-wei Liao6a60f4e2012-01-17 02:58:40 -080079 for (size_t i = 0; i < 2; ++i) {
Logan474cbd22011-01-31 01:47:44 +080080 delete mSourceList[i];
Shih-wei Liao6a60f4e2012-01-17 02:58:40 -080081 }
Logancf3e5212010-12-29 01:44:55 +080082}
83
84
Logan474cbd22011-01-31 01:47:44 +080085int Script::addSourceBC(size_t idx,
86 char const *resName,
87 const char *bitcode,
88 size_t bitcodeSize,
89 unsigned long flags) {
Shih-wei Liao898c5a92011-05-18 07:02:39 -070090
91 if (!resName) {
92 mErrorCode = BCC_INVALID_VALUE;
Steve Block10c14122012-01-08 10:15:06 +000093 ALOGE("Invalid argument: resName = NULL\n");
Shih-wei Liao898c5a92011-05-18 07:02:39 -070094 return 1;
95 }
96
Loganecf4cbd2011-01-06 05:34:11 +080097 if (mStatus != ScriptStatus::Unknown) {
Logancf3e5212010-12-29 01:44:55 +080098 mErrorCode = BCC_INVALID_OPERATION;
Steve Block10c14122012-01-08 10:15:06 +000099 ALOGE("Bad operation: Adding source after bccPrepareExecutable\n");
Logancf3e5212010-12-29 01:44:55 +0800100 return 1;
101 }
102
Logan474cbd22011-01-31 01:47:44 +0800103 if (!bitcode) {
104 mErrorCode = BCC_INVALID_VALUE;
Steve Block10c14122012-01-08 10:15:06 +0000105 ALOGE("Invalid argument: bitcode = NULL\n");
Logan474cbd22011-01-31 01:47:44 +0800106 return 1;
107 }
108
109 mSourceList[idx] = SourceInfo::createFromBuffer(resName,
110 bitcode, bitcodeSize,
111 flags);
112
113 if (!mSourceList[idx]) {
114 mErrorCode = BCC_OUT_OF_MEMORY;
Steve Block10c14122012-01-08 10:15:06 +0000115 ALOGE("Out of memory while adding source bitcode\n");
Logan474cbd22011-01-31 01:47:44 +0800116 return 1;
117 }
118
Loganecf4cbd2011-01-06 05:34:11 +0800119 return 0;
Logancf3e5212010-12-29 01:44:55 +0800120}
121
122
Logan474cbd22011-01-31 01:47:44 +0800123int Script::addSourceModule(size_t idx,
124 llvm::Module *module,
125 unsigned long flags) {
Logancf3e5212010-12-29 01:44:55 +0800126 if (mStatus != ScriptStatus::Unknown) {
127 mErrorCode = BCC_INVALID_OPERATION;
Steve Block10c14122012-01-08 10:15:06 +0000128 ALOGE("Bad operation: Adding source after bccPrepareExecutable\n");
Logancf3e5212010-12-29 01:44:55 +0800129 return 1;
130 }
131
Logan474cbd22011-01-31 01:47:44 +0800132 if (!module) {
133 mErrorCode = BCC_INVALID_VALUE;
Steve Block10c14122012-01-08 10:15:06 +0000134 ALOGE("Invalid argument: module = NULL\n");
Logan474cbd22011-01-31 01:47:44 +0800135 return 1;
136 }
137
138 mSourceList[idx] = SourceInfo::createFromModule(module, flags);
139
140 if (!mSourceList[idx]) {
141 mErrorCode = BCC_OUT_OF_MEMORY;
Steve Block10c14122012-01-08 10:15:06 +0000142 ALOGE("Out of memory when add source module\n");
Logan474cbd22011-01-31 01:47:44 +0800143 return 1;
144 }
145
Loganecf4cbd2011-01-06 05:34:11 +0800146 return 0;
Logancf3e5212010-12-29 01:44:55 +0800147}
148
149
Logan474cbd22011-01-31 01:47:44 +0800150int Script::addSourceFile(size_t idx,
151 char const *path,
152 unsigned long flags) {
Logan3133c412011-01-06 06:15:40 +0800153 if (mStatus != ScriptStatus::Unknown) {
Logancf3e5212010-12-29 01:44:55 +0800154 mErrorCode = BCC_INVALID_OPERATION;
Steve Block10c14122012-01-08 10:15:06 +0000155 ALOGE("Bad operation: Adding source after bccPrepareExecutable\n");
Logancf3e5212010-12-29 01:44:55 +0800156 return 1;
157 }
158
Logan474cbd22011-01-31 01:47:44 +0800159 if (!path) {
160 mErrorCode = BCC_INVALID_VALUE;
Steve Block10c14122012-01-08 10:15:06 +0000161 ALOGE("Invalid argument: path = NULL\n");
Logan474cbd22011-01-31 01:47:44 +0800162 return 1;
163 }
164
165 struct stat sb;
166 if (stat(path, &sb) != 0) {
167 mErrorCode = BCC_INVALID_VALUE;
Steve Block10c14122012-01-08 10:15:06 +0000168 ALOGE("File not found: %s\n", path);
Logan474cbd22011-01-31 01:47:44 +0800169 return 1;
170 }
171
172 mSourceList[idx] = SourceInfo::createFromFile(path, flags);
173
174 if (!mSourceList[idx]) {
175 mErrorCode = BCC_OUT_OF_MEMORY;
Steve Block10c14122012-01-08 10:15:06 +0000176 ALOGE("Out of memory while adding source file\n");
Logan474cbd22011-01-31 01:47:44 +0800177 return 1;
178 }
179
Logan3133c412011-01-06 06:15:40 +0800180 return 0;
Logancf3e5212010-12-29 01:44:55 +0800181}
182
Shih-wei Liao6a60f4e2012-01-17 02:58:40 -0800183int Script::prepareRelocatable(char const *cacheDir,
184 char const *cacheName,
185 llvm::Reloc::Model RelocModel,
186 unsigned long flags) {
Zonr Chang4ea08862012-01-17 17:26:49 +0800187 mObjectType = ScriptObject::Relocatable;
Joseph Wen34c600a2011-07-25 17:59:17 -0700188#if USE_CACHE
189 if (cacheDir && cacheName) {
190 // Set Cache Directory and File Name
191 mCacheDir = cacheDir;
192 mCacheName = cacheName;
193
194 if (!mCacheDir.empty() && *mCacheDir.rbegin() != '/') {
195 mCacheDir.push_back('/'); // Ensure mCacheDir is end with '/'
196 }
197
198 // Check Cache File
199 if (internalLoadCache(true) == 0) {
200 return 0;
201 }
202 }
203#endif
Zonr Chang2fcbd022012-01-06 21:04:31 +0800204
205 CompilerOption option;
Shih-wei Liao8afed382012-01-10 15:57:24 +0800206 option.RelocModelOpt = RelocModel;
Zonr Chang2fcbd022012-01-06 21:04:31 +0800207 option.LoadAfterCompile = false;
208 int status = internalCompile(option);
Joseph Wen34c600a2011-07-25 17:59:17 -0700209 if (status != 0) {
Steve Block10c14122012-01-08 10:15:06 +0000210 ALOGE("LLVM error message: %s\n", getCompilerErrorMessage());
Joseph Wen34c600a2011-07-25 17:59:17 -0700211 }
212 return status;
213}
214
Logancf3e5212010-12-29 01:44:55 +0800215
Logan Chien311c26f2011-07-11 14:30:34 +0800216int Script::prepareExecutable(char const *cacheDir,
217 char const *cacheName,
218 unsigned long flags) {
Loganecf4cbd2011-01-06 05:34:11 +0800219 if (mStatus != ScriptStatus::Unknown) {
Logancf3e5212010-12-29 01:44:55 +0800220 mErrorCode = BCC_INVALID_OPERATION;
Steve Block10c14122012-01-08 10:15:06 +0000221 ALOGE("Invalid operation: %s\n", __func__);
Logancf3e5212010-12-29 01:44:55 +0800222 return 1;
223 }
224
Zonr Chang4ea08862012-01-17 17:26:49 +0800225 mObjectType = ScriptObject::Executable;
Logan35849002011-01-15 07:30:43 +0800226#if USE_CACHE
Logan Chien311c26f2011-07-11 14:30:34 +0800227 if (cacheDir && cacheName) {
228 // Set Cache Directory and File Name
229 mCacheDir = cacheDir;
230 mCacheName = cacheName;
231
232 if (!mCacheDir.empty() && *mCacheDir.rbegin() != '/') {
233 mCacheDir.push_back('/'); // Ensure mCacheDir is end with '/'
234 }
235
236 // Load Cache File
Joseph Wen34c600a2011-07-25 17:59:17 -0700237 if (internalLoadCache(false) == 0) {
Logan Chien311c26f2011-07-11 14:30:34 +0800238 return 0;
239 }
Logan033f46e2011-01-06 05:51:24 +0800240 }
Logan35849002011-01-15 07:30:43 +0800241#endif
Loganecf4cbd2011-01-06 05:34:11 +0800242
Zonr Chang2fcbd022012-01-06 21:04:31 +0800243 CompilerOption option;
244 int status = internalCompile(option);
Stephen Hines27b35102011-05-11 17:58:48 -0700245 if (status != 0) {
Steve Block10c14122012-01-08 10:15:06 +0000246 ALOGE("LLVM error message: %s\n", getCompilerErrorMessage());
Stephen Hines27b35102011-05-11 17:58:48 -0700247 }
248 return status;
Logan033f46e2011-01-06 05:51:24 +0800249}
250
251
Logan35849002011-01-15 07:30:43 +0800252#if USE_CACHE
Joseph Wen34c600a2011-07-25 17:59:17 -0700253int Script::internalLoadCache(bool checkOnly) {
Joseph Wen76919072011-07-07 23:06:15 -0700254 if (getBooleanProp("debug.bcc.nocache")) {
Logan033f46e2011-01-06 05:51:24 +0800255 // Android system environment property disable the cache mechanism by
256 // setting "debug.bcc.nocache". So we will not load the cache file any
257 // way.
258 return 1;
259 }
260
Logan Chien311c26f2011-07-11 14:30:34 +0800261 if (mCacheDir.empty() || mCacheName.empty()) {
Loganf340bf72011-01-14 17:51:40 +0800262 // The application developer has not specify the cachePath, so
Logan04329712011-01-06 06:10:57 +0800263 // we don't know where to open the cache file.
264 return 1;
Logan033f46e2011-01-06 05:51:24 +0800265 }
Logan04329712011-01-06 06:10:57 +0800266
Zonr Chang4ea08862012-01-17 17:26:49 +0800267 std::string objPath = getCachedObjectPath();
268 std::string infoPath = getCacheInfoPath();
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700269
Logan Chien311c26f2011-07-11 14:30:34 +0800270 FileHandle objFile;
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700271 if (objFile.open(objPath.c_str(), OpenMode::Read) < 0) {
Logan Chien03a2e302011-07-13 21:46:32 +0800272 // Unable to open the executable file in read mode.
Logan04329712011-01-06 06:10:57 +0800273 return 1;
274 }
275
Logan Chien311c26f2011-07-11 14:30:34 +0800276 FileHandle infoFile;
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700277 if (infoFile.open(infoPath.c_str(), OpenMode::Read) < 0) {
Logan Chien03a2e302011-07-13 21:46:32 +0800278 // Unable to open the metadata information file in read mode.
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700279 return 1;
280 }
281
Logan Chien311c26f2011-07-11 14:30:34 +0800282#if USE_OLD_JIT
283 CacheReader reader;
284#elif USE_MCJIT
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700285 MCCacheReader reader;
286
287 // Register symbol lookup function
288 if (mpExtSymbolLookupFn) {
289 reader.registerSymbolCallback(mpExtSymbolLookupFn,
290 mpExtSymbolLookupFnContext);
291 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700292#endif
Logan04329712011-01-06 06:10:57 +0800293
Logan9a5f8682011-01-07 06:09:57 +0800294 // Dependencies
Joseph Wen2ca6e572011-06-24 14:12:23 -0700295 reader.addDependency(BCC_FILE_RESOURCE, pathLibBCC_SHA1, sha1LibBCC_SHA1);
Joseph Wen76919072011-07-07 23:06:15 -0700296 reader.addDependency(BCC_FILE_RESOURCE, pathLibRS, sha1LibRS);
Logan9a5f8682011-01-07 06:09:57 +0800297
Logan474cbd22011-01-31 01:47:44 +0800298 for (size_t i = 0; i < 2; ++i) {
299 if (mSourceList[i]) {
300 mSourceList[i]->introDependency(reader);
301 }
Logan9a5f8682011-01-07 06:09:57 +0800302 }
303
Joseph Wen34c600a2011-07-25 17:59:17 -0700304 if (checkOnly)
Joseph Wen49281042011-07-26 10:04:09 -0700305 return !reader.checkCacheFile(&objFile, &infoFile, this);
Joseph Wen34c600a2011-07-25 17:59:17 -0700306
Logan9a5f8682011-01-07 06:09:57 +0800307 // Read cache file
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700308 ScriptCached *cached = reader.readCacheFile(&objFile, &infoFile, this);
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700309
Logan04329712011-01-06 06:10:57 +0800310 if (!cached) {
Logan42598052011-01-26 22:41:13 +0800311 mIsContextSlotNotAvail = reader.isContextSlotNotAvail();
Logan04329712011-01-06 06:10:57 +0800312 return 1;
313 }
314
315 mCached = cached;
316 mStatus = ScriptStatus::Cached;
Logan033f46e2011-01-06 05:51:24 +0800317
Loganf3c83ce2011-01-07 06:36:33 +0800318 // Dirty hack for libRS.
319 // TODO(all): This dirty hack should be removed in the future.
Shih-wei Liao8eb5fe92011-02-01 04:17:38 -0800320 if (!cached->isLibRSThreadable() && mpExtSymbolLookupFn) {
Loganf3c83ce2011-01-07 06:36:33 +0800321 mpExtSymbolLookupFn(mpExtSymbolLookupFnContext, "__clearThreadable");
322 }
323
Loganf7f0ac52011-01-07 03:53:43 +0800324 return 0;
Logan033f46e2011-01-06 05:51:24 +0800325}
Logan35849002011-01-15 07:30:43 +0800326#endif
Logan033f46e2011-01-06 05:51:24 +0800327
Shih-wei Liao9e81e372012-01-17 16:38:40 -0800328int Script::internalCompile(const CompilerOption &option) {
Logan033f46e2011-01-06 05:51:24 +0800329 // Create the ScriptCompiled object
Nowar Gu09b6c1c2011-05-24 23:49:07 +0800330 mCompiled = new (std::nothrow) ScriptCompiled(this);
Loganecf4cbd2011-01-06 05:34:11 +0800331
332 if (!mCompiled) {
333 mErrorCode = BCC_OUT_OF_MEMORY;
Steve Block10c14122012-01-08 10:15:06 +0000334 ALOGE("Out of memory: %s %d\n", __FILE__, __LINE__);
Loganecf4cbd2011-01-06 05:34:11 +0800335 return 1;
336 }
337
338 mStatus = ScriptStatus::Compiled;
339
Logan033f46e2011-01-06 05:51:24 +0800340 // Register symbol lookup function
Loganecf4cbd2011-01-06 05:34:11 +0800341 if (mpExtSymbolLookupFn) {
342 mCompiled->registerSymbolCallback(mpExtSymbolLookupFn,
343 mpExtSymbolLookupFnContext);
344 }
345
Zonr Changdf3fee42012-01-10 15:58:36 +0800346 if (!mSourceList[0]) {
347 ALOGE("Source bitcode is not set.\n");
Logan474cbd22011-01-31 01:47:44 +0800348 return 1;
349 }
350
Zonr Changdf3fee42012-01-10 15:58:36 +0800351 // Parse Bitcode File (if necessary)
352 if (mSourceList[0]->prepareModule() != 0)
353 return 1;
354
355 // Set the main source module
356 if (mCompiled->readModule(mSourceList[0]->getModule()) != 0) {
Steve Block10c14122012-01-08 10:15:06 +0000357 ALOGE("Unable to read source module\n");
Logan474cbd22011-01-31 01:47:44 +0800358 return 1;
Loganecf4cbd2011-01-06 05:34:11 +0800359 }
360
Logan3133c412011-01-06 06:15:40 +0800361 // Link the source module with the library module
Zonr Changdf3fee42012-01-10 15:58:36 +0800362 if (mSourceList[1] &&
363 mSourceList[1]->prepareModule(mSourceList[0]->getContext())) {
364 if (mCompiled->linkModule(mSourceList[1]->getModule()) != 0) {
Steve Block10c14122012-01-08 10:15:06 +0000365 ALOGE("Unable to link library module\n");
Logan04329712011-01-06 06:10:57 +0800366 return 1;
367 }
368 }
Loganecf4cbd2011-01-06 05:34:11 +0800369
Logan3133c412011-01-06 06:15:40 +0800370 // Compile and JIT the code
Zonr Chang2fcbd022012-01-06 21:04:31 +0800371 if (mCompiled->compile(option) != 0) {
Steve Block10c14122012-01-08 10:15:06 +0000372 ALOGE("Unable to compile.\n");
Logan04329712011-01-06 06:10:57 +0800373 return 1;
374 }
375
Logan35849002011-01-15 07:30:43 +0800376#if USE_CACHE
Logan42598052011-01-26 22:41:13 +0800377 // Note: If we re-compile the script because the cached context slot not
378 // available, then we don't have to write the cache.
379
380 // Note: If the address of the context is not in the context slot, then
381 // we don't have to cache it.
382
Logan Chien311c26f2011-07-11 14:30:34 +0800383 if (!mCacheDir.empty() &&
384 !mCacheName.empty() &&
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700385#if USE_OLD_JIT
Logan1dc63142011-02-25 17:14:51 +0800386 !mIsContextSlotNotAvail &&
387 ContextManager::get().isManagingContext(getContext()) &&
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700388#endif
Logan42598052011-01-26 22:41:13 +0800389 !getBooleanProp("debug.bcc.nocache")) {
390
Zonr Chang4ea08862012-01-17 17:26:49 +0800391 std::string objPath = getCachedObjectPath();
392 std::string infoPath = getCacheInfoPath();
Logan Chien311c26f2011-07-11 14:30:34 +0800393
Jeff Brown937a0bc2011-01-26 23:20:14 -0800394 // Remove the file if it already exists before writing the new file.
395 // The old file may still be mapped elsewhere in memory and we do not want
396 // to modify its contents. (The same script may be running concurrently in
397 // the same process or a different process!)
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700398 ::unlink(objPath.c_str());
Logan Chien311c26f2011-07-11 14:30:34 +0800399#if !USE_OLD_JIT && USE_MCJIT
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700400 ::unlink(infoPath.c_str());
401#endif
Jeff Brown937a0bc2011-01-26 23:20:14 -0800402
Logan Chien03a2e302011-07-13 21:46:32 +0800403 FileHandle objFile;
404 FileHandle infoFile;
405
406 if (objFile.open(objPath.c_str(), OpenMode::Write) >= 0 &&
407 infoFile.open(infoPath.c_str(), OpenMode::Write) >= 0) {
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700408
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700409#if USE_OLD_JIT
Logan04329712011-01-06 06:10:57 +0800410 CacheWriter writer;
Logan Chien311c26f2011-07-11 14:30:34 +0800411#elif USE_MCJIT
412 MCCacheWriter writer;
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700413#endif
Logana27a83f2011-01-07 10:25:48 +0800414
Joseph Wen2ca6e572011-06-24 14:12:23 -0700415#ifdef TARGET_BUILD
Logana2e15af2011-01-07 11:46:08 +0800416 // Dependencies
Joseph Wen2ca6e572011-06-24 14:12:23 -0700417 writer.addDependency(BCC_FILE_RESOURCE, pathLibBCC_SHA1, sha1LibBCC_SHA1);
Joseph Wen76919072011-07-07 23:06:15 -0700418 writer.addDependency(BCC_FILE_RESOURCE, pathLibRS, sha1LibRS);
Logane1323992011-01-12 04:47:13 +0800419#endif
Logana2e15af2011-01-07 11:46:08 +0800420
Logan474cbd22011-01-31 01:47:44 +0800421 for (size_t i = 0; i < 2; ++i) {
Logan825c3b22011-02-28 05:05:48 +0800422 if (mSourceList[i]) {
423 mSourceList[i]->introDependency(writer);
424 }
Logana2e15af2011-01-07 11:46:08 +0800425 }
426
Logana27a83f2011-01-07 10:25:48 +0800427 // libRS is threadable dirty hack
428 // TODO: This should be removed in the future
429 uint32_t libRS_threadable = 0;
430 if (mpExtSymbolLookupFn) {
Logan89eb47f2011-01-07 10:45:16 +0800431 libRS_threadable =
432 (uint32_t)mpExtSymbolLookupFn(mpExtSymbolLookupFnContext,
433 "__isThreadable");
Logana27a83f2011-01-07 10:25:48 +0800434 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700435
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700436 if (!writer.writeCacheFile(&objFile, &infoFile, this, libRS_threadable)) {
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700437 objFile.truncate();
438 objFile.close();
Logana27a83f2011-01-07 10:25:48 +0800439
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700440 if (unlink(objPath.c_str()) != 0) {
Steve Block10c14122012-01-08 10:15:06 +0000441 ALOGE("Unable to remove the invalid cache file: %s. (reason: %s)\n",
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700442 objPath.c_str(), strerror(errno));
Logan89eb47f2011-01-07 10:45:16 +0800443 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700444
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700445 infoFile.truncate();
446 infoFile.close();
447
448 if (unlink(infoPath.c_str()) != 0) {
Steve Block10c14122012-01-08 10:15:06 +0000449 ALOGE("Unable to remove the invalid cache file: %s. (reason: %s)\n",
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700450 infoPath.c_str(), strerror(errno));
451 }
Logan89eb47f2011-01-07 10:45:16 +0800452 }
453 }
Logan04329712011-01-06 06:10:57 +0800454 }
Logan35849002011-01-15 07:30:43 +0800455#endif // USE_CACHE
Logan04329712011-01-06 06:10:57 +0800456
457 return 0;
Logancf3e5212010-12-29 01:44:55 +0800458}
459
460
461char const *Script::getCompilerErrorMessage() {
462 if (mStatus != ScriptStatus::Compiled) {
463 mErrorCode = BCC_INVALID_OPERATION;
464 return NULL;
465 }
466
467 return mCompiled->getCompilerErrorMessage();
468}
469
470
471void *Script::lookup(const char *name) {
Logan89eb47f2011-01-07 10:45:16 +0800472 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700473 case ScriptStatus::Compiled: {
474 return mCompiled->lookup(name);
475 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700476
Logan35849002011-01-15 07:30:43 +0800477#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700478 case ScriptStatus::Cached: {
479 return mCached->lookup(name);
480 }
Logan35849002011-01-15 07:30:43 +0800481#endif
Logan89eb47f2011-01-07 10:45:16 +0800482
Shih-wei Liaod50be322011-07-01 22:53:31 -0700483 default: {
484 mErrorCode = BCC_INVALID_OPERATION;
485 return NULL;
486 }
Logancf3e5212010-12-29 01:44:55 +0800487 }
Logancf3e5212010-12-29 01:44:55 +0800488}
489
490
Loganbe79ada2011-01-13 01:33:45 +0800491size_t Script::getExportVarCount() const {
Logan89eb47f2011-01-07 10:45:16 +0800492 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700493 case ScriptStatus::Compiled: {
494 return mCompiled->getExportVarCount();
495 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700496
Logan35849002011-01-15 07:30:43 +0800497#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700498 case ScriptStatus::Cached: {
499 return mCached->getExportVarCount();
500 }
Logan35849002011-01-15 07:30:43 +0800501#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700502
Shih-wei Liaod50be322011-07-01 22:53:31 -0700503 default: {
504 return 0;
505 }
Loganbe79ada2011-01-13 01:33:45 +0800506 }
507}
508
509
510size_t Script::getExportFuncCount() const {
511 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700512 case ScriptStatus::Compiled: {
513 return mCompiled->getExportFuncCount();
514 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700515
Logan35849002011-01-15 07:30:43 +0800516#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700517 case ScriptStatus::Cached: {
518 return mCached->getExportFuncCount();
519 }
Logan35849002011-01-15 07:30:43 +0800520#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700521
Shih-wei Liaod50be322011-07-01 22:53:31 -0700522 default: {
523 return 0;
524 }
Loganbe79ada2011-01-13 01:33:45 +0800525 }
526}
527
528
529size_t Script::getPragmaCount() const {
530 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700531 case ScriptStatus::Compiled: {
532 return mCompiled->getPragmaCount();
533 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700534
Logan35849002011-01-15 07:30:43 +0800535#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700536 case ScriptStatus::Cached: {
537 return mCached->getPragmaCount();
538 }
Logan35849002011-01-15 07:30:43 +0800539#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700540
Shih-wei Liaod50be322011-07-01 22:53:31 -0700541 default: {
542 return 0;
543 }
Loganbe79ada2011-01-13 01:33:45 +0800544 }
545}
546
547
548size_t Script::getFuncCount() const {
549 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700550 case ScriptStatus::Compiled: {
551 return mCompiled->getFuncCount();
552 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700553
Logan35849002011-01-15 07:30:43 +0800554#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700555 case ScriptStatus::Cached: {
556 return mCached->getFuncCount();
557 }
Logan35849002011-01-15 07:30:43 +0800558#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700559
Shih-wei Liaod50be322011-07-01 22:53:31 -0700560 default: {
561 return 0;
562 }
Loganbe79ada2011-01-13 01:33:45 +0800563 }
564}
565
566
Stephen Hines071288a2011-01-27 14:38:26 -0800567size_t Script::getObjectSlotCount() const {
568 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700569 case ScriptStatus::Compiled: {
570 return mCompiled->getObjectSlotCount();
571 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700572
Stephen Hines071288a2011-01-27 14:38:26 -0800573#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700574 case ScriptStatus::Cached: {
575 return mCached->getObjectSlotCount();
576 }
Stephen Hines071288a2011-01-27 14:38:26 -0800577#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700578
Shih-wei Liaod50be322011-07-01 22:53:31 -0700579 default: {
580 return 0;
581 }
Stephen Hines071288a2011-01-27 14:38:26 -0800582 }
583}
584
585
Loganbe79ada2011-01-13 01:33:45 +0800586void Script::getExportVarList(size_t varListSize, void **varList) {
587 switch (mStatus) {
588#define DELEGATE(STATUS) \
Shih-wei Liaod50be322011-07-01 22:53:31 -0700589 case ScriptStatus::STATUS: \
590 m##STATUS->getExportVarList(varListSize, varList); \
591 break;
Logancf3e5212010-12-29 01:44:55 +0800592
Logan35849002011-01-15 07:30:43 +0800593#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700594 DELEGATE(Cached);
Logan35849002011-01-15 07:30:43 +0800595#endif
596
Shih-wei Liaod50be322011-07-01 22:53:31 -0700597 DELEGATE(Compiled);
Loganbe79ada2011-01-13 01:33:45 +0800598#undef DELEGATE
Logan89eb47f2011-01-07 10:45:16 +0800599
Shih-wei Liaod50be322011-07-01 22:53:31 -0700600 default: {
601 mErrorCode = BCC_INVALID_OPERATION;
602 }
Logan89eb47f2011-01-07 10:45:16 +0800603 }
Logancf3e5212010-12-29 01:44:55 +0800604}
605
Joseph Wenf36637f2011-07-06 18:27:12 -0700606void Script::getExportVarNameList(std::vector<std::string> &varList) {
607 switch (mStatus) {
608 case ScriptStatus::Compiled: {
609 return mCompiled->getExportVarNameList(varList);
610 }
611
612 default: {
613 mErrorCode = BCC_INVALID_OPERATION;
614 }
615 }
616}
617
Logancf3e5212010-12-29 01:44:55 +0800618
Loganbe79ada2011-01-13 01:33:45 +0800619void Script::getExportFuncList(size_t funcListSize, void **funcList) {
Logan89eb47f2011-01-07 10:45:16 +0800620 switch (mStatus) {
Loganbe79ada2011-01-13 01:33:45 +0800621#define DELEGATE(STATUS) \
Shih-wei Liaod50be322011-07-01 22:53:31 -0700622 case ScriptStatus::STATUS: \
623 m##STATUS->getExportFuncList(funcListSize, funcList); \
624 break;
Logancf3e5212010-12-29 01:44:55 +0800625
Logan35849002011-01-15 07:30:43 +0800626#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700627 DELEGATE(Cached);
Logan35849002011-01-15 07:30:43 +0800628#endif
629
Shih-wei Liaod50be322011-07-01 22:53:31 -0700630 DELEGATE(Compiled);
Loganbe79ada2011-01-13 01:33:45 +0800631#undef DELEGATE
Logan89eb47f2011-01-07 10:45:16 +0800632
Shih-wei Liaod50be322011-07-01 22:53:31 -0700633 default: {
634 mErrorCode = BCC_INVALID_OPERATION;
635 }
Logan89eb47f2011-01-07 10:45:16 +0800636 }
Logancf3e5212010-12-29 01:44:55 +0800637}
638
Joseph Wenf36637f2011-07-06 18:27:12 -0700639void Script::getExportFuncNameList(std::vector<std::string> &funcList) {
640 switch (mStatus) {
641 case ScriptStatus::Compiled: {
642 return mCompiled->getExportFuncNameList(funcList);
643 }
644
645 default: {
646 mErrorCode = BCC_INVALID_OPERATION;
647 }
648 }
649}
650
Logancf3e5212010-12-29 01:44:55 +0800651
Loganbe79ada2011-01-13 01:33:45 +0800652void Script::getPragmaList(size_t pragmaListSize,
653 char const **keyList,
654 char const **valueList) {
Logan89eb47f2011-01-07 10:45:16 +0800655 switch (mStatus) {
Loganbe79ada2011-01-13 01:33:45 +0800656#define DELEGATE(STATUS) \
Shih-wei Liaod50be322011-07-01 22:53:31 -0700657 case ScriptStatus::STATUS: \
658 m##STATUS->getPragmaList(pragmaListSize, keyList, valueList); \
659 break;
Logancf3e5212010-12-29 01:44:55 +0800660
Logan35849002011-01-15 07:30:43 +0800661#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700662 DELEGATE(Cached);
Logan35849002011-01-15 07:30:43 +0800663#endif
664
Shih-wei Liaod50be322011-07-01 22:53:31 -0700665 DELEGATE(Compiled);
Loganbe79ada2011-01-13 01:33:45 +0800666#undef DELEGATE
Logan89eb47f2011-01-07 10:45:16 +0800667
Shih-wei Liaod50be322011-07-01 22:53:31 -0700668 default: {
669 mErrorCode = BCC_INVALID_OPERATION;
670 }
Logan89eb47f2011-01-07 10:45:16 +0800671 }
Logancf3e5212010-12-29 01:44:55 +0800672}
673
674
Loganf340bf72011-01-14 17:51:40 +0800675void Script::getFuncInfoList(size_t funcInfoListSize,
676 FuncInfo *funcInfoList) {
Logan89eb47f2011-01-07 10:45:16 +0800677 switch (mStatus) {
Loganbe79ada2011-01-13 01:33:45 +0800678#define DELEGATE(STATUS) \
Shih-wei Liaod50be322011-07-01 22:53:31 -0700679 case ScriptStatus::STATUS: \
680 m##STATUS->getFuncInfoList(funcInfoListSize, funcInfoList); \
681 break;
Logancf3e5212010-12-29 01:44:55 +0800682
Logan35849002011-01-15 07:30:43 +0800683#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700684 DELEGATE(Cached);
Logan35849002011-01-15 07:30:43 +0800685#endif
686
Shih-wei Liaod50be322011-07-01 22:53:31 -0700687 DELEGATE(Compiled);
Loganbe79ada2011-01-13 01:33:45 +0800688#undef DELEGATE
Logan89eb47f2011-01-07 10:45:16 +0800689
Shih-wei Liaod50be322011-07-01 22:53:31 -0700690 default: {
691 mErrorCode = BCC_INVALID_OPERATION;
692 }
Logan89eb47f2011-01-07 10:45:16 +0800693 }
Logancf3e5212010-12-29 01:44:55 +0800694}
695
Stephen Hines071288a2011-01-27 14:38:26 -0800696
697void Script::getObjectSlotList(size_t objectSlotListSize,
698 uint32_t *objectSlotList) {
699 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700700#define DELEGATE(STATUS) \
701 case ScriptStatus::STATUS: \
702 m##STATUS->getObjectSlotList(objectSlotListSize, objectSlotList); \
703 break;
Stephen Hines071288a2011-01-27 14:38:26 -0800704
705#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700706 DELEGATE(Cached);
Stephen Hines071288a2011-01-27 14:38:26 -0800707#endif
708
Shih-wei Liaod50be322011-07-01 22:53:31 -0700709 DELEGATE(Compiled);
Stephen Hines071288a2011-01-27 14:38:26 -0800710#undef DELEGATE
711
Shih-wei Liaod50be322011-07-01 22:53:31 -0700712 default: {
713 mErrorCode = BCC_INVALID_OPERATION;
714 }
Stephen Hines071288a2011-01-27 14:38:26 -0800715 }
716}
717
718
Logan Chiend2a5f302011-07-19 20:32:25 +0800719#if USE_OLD_JIT
Logana27a83f2011-01-07 10:25:48 +0800720char *Script::getContext() {
721 switch (mStatus) {
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700722
Logan35849002011-01-15 07:30:43 +0800723#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700724 case ScriptStatus::Cached: {
725 return mCached->getContext();
726 }
Logan35849002011-01-15 07:30:43 +0800727#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700728
Shih-wei Liaod50be322011-07-01 22:53:31 -0700729 case ScriptStatus::Compiled: {
730 return mCompiled->getContext();
731 }
Logana27a83f2011-01-07 10:25:48 +0800732
Shih-wei Liaod50be322011-07-01 22:53:31 -0700733 default: {
734 mErrorCode = BCC_INVALID_OPERATION;
735 return NULL;
736 }
Logan02286cb2011-01-07 00:30:47 +0800737 }
Logan02286cb2011-01-07 00:30:47 +0800738}
Logan Chiend2a5f302011-07-19 20:32:25 +0800739#endif
Logan02286cb2011-01-07 00:30:47 +0800740
Logancf3e5212010-12-29 01:44:55 +0800741
Shih-wei Liaoce82d492011-01-20 12:34:03 -0800742int Script::registerSymbolCallback(BCCSymbolLookupFn pFn, void *pContext) {
Logancf3e5212010-12-29 01:44:55 +0800743 mpExtSymbolLookupFn = pFn;
744 mpExtSymbolLookupFnContext = pContext;
745
Logan7d2219f2011-01-06 06:19:25 +0800746 if (mStatus != ScriptStatus::Unknown) {
Logancf3e5212010-12-29 01:44:55 +0800747 mErrorCode = BCC_INVALID_OPERATION;
Steve Block10c14122012-01-08 10:15:06 +0000748 ALOGE("Invalid operation: %s\n", __func__);
Shih-wei Liaoce82d492011-01-20 12:34:03 -0800749 return 1;
Logancf3e5212010-12-29 01:44:55 +0800750 }
Shih-wei Liaoce82d492011-01-20 12:34:03 -0800751 return 0;
Logancf3e5212010-12-29 01:44:55 +0800752}
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700753
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700754#if USE_MCJIT
755size_t Script::getELFSize() const {
756 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700757 case ScriptStatus::Compiled: {
758 return mCompiled->getELFSize();
759 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700760
Shih-wei Liaod50be322011-07-01 22:53:31 -0700761 default: {
762 return 0;
763 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700764 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700765}
766
767const char *Script::getELF() const {
768 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700769 case ScriptStatus::Compiled: {
770 return mCompiled->getELF();
771 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700772
Shih-wei Liaod50be322011-07-01 22:53:31 -0700773 default: {
774 return NULL;
775 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700776 }
777}
778#endif
Logancf3e5212010-12-29 01:44:55 +0800779
780} // namespace bcc