blob: ee18f4709de7a12e170a67d5ac6cd65b997300ff [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
Loganf7f0ac52011-01-07 03:53:43 +080021#include "CacheReader.h"
Logan89eb47f2011-01-07 10:45:16 +080022#include "CacheWriter.h"
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -070023#include "MCCacheReader.h"
24#include "MCCacheWriter.h"
Logan42598052011-01-26 22:41:13 +080025#include "ContextManager.h"
Logan4dcd6792011-02-28 05:12:00 +080026#include "DebugHelper.h"
Logan04329712011-01-06 06:10:57 +080027#include "FileHandle.h"
Logancf3e5212010-12-29 01:44:55 +080028#include "ScriptCompiled.h"
Logan9a5f8682011-01-07 06:09:57 +080029#include "ScriptCached.h"
30#include "Sha1Helper.h"
Logan474cbd22011-01-31 01:47:44 +080031#include "SourceInfo.h"
Logancf3e5212010-12-29 01:44:55 +080032
Logan89eb47f2011-01-07 10:45:16 +080033#include <errno.h>
Logan474cbd22011-01-31 01:47:44 +080034#include <sys/stat.h>
35#include <sys/types.h>
Logancf3e5212010-12-29 01:44:55 +080036
Logan89eb47f2011-01-07 10:45:16 +080037#include <new>
38#include <string.h>
Logan033f46e2011-01-06 05:51:24 +080039#include <cutils/properties.h>
40
Logan89eb47f2011-01-07 10:45:16 +080041
Loganecf4cbd2011-01-06 05:34:11 +080042namespace {
43
Logan033f46e2011-01-06 05:51:24 +080044bool getBooleanProp(const char *str) {
Loganf340bf72011-01-14 17:51:40 +080045 char buf[PROPERTY_VALUE_MAX];
46 property_get(str, buf, "0");
47 return strcmp(buf, "0") != 0;
Logan033f46e2011-01-06 05:51:24 +080048}
49
Loganecf4cbd2011-01-06 05:34:11 +080050} // namespace anonymous
51
Logancf3e5212010-12-29 01:44:55 +080052namespace bcc {
53
54Script::~Script() {
Logan35849002011-01-15 07:30:43 +080055 switch (mStatus) {
56 case ScriptStatus::Compiled:
Logancf3e5212010-12-29 01:44:55 +080057 delete mCompiled;
Logan35849002011-01-15 07:30:43 +080058 break;
59
60#if USE_CACHE
61 case ScriptStatus::Cached:
Shih-wei Liaoc4cf6542011-01-13 01:43:01 -080062 delete mCached;
Logan35849002011-01-15 07:30:43 +080063 break;
64#endif
65
66 default:
67 break;
Logancf3e5212010-12-29 01:44:55 +080068 }
Logan474cbd22011-01-31 01:47:44 +080069
70 for (size_t i = 0; i < 2; ++i) {
71 delete mSourceList[i];
72 }
Logancf3e5212010-12-29 01:44:55 +080073}
74
75
Logan474cbd22011-01-31 01:47:44 +080076int Script::addSourceBC(size_t idx,
77 char const *resName,
78 const char *bitcode,
79 size_t bitcodeSize,
80 unsigned long flags) {
Shih-wei Liao898c5a92011-05-18 07:02:39 -070081
82 if (!resName) {
83 mErrorCode = BCC_INVALID_VALUE;
84 LOGE("Invalid argument: resName = NULL\n");
85 return 1;
86 }
87
Loganecf4cbd2011-01-06 05:34:11 +080088 if (mStatus != ScriptStatus::Unknown) {
Logancf3e5212010-12-29 01:44:55 +080089 mErrorCode = BCC_INVALID_OPERATION;
Logan474cbd22011-01-31 01:47:44 +080090 LOGE("Bad operation: Adding source after bccPrepareExecutable\n");
Logancf3e5212010-12-29 01:44:55 +080091 return 1;
92 }
93
Logan474cbd22011-01-31 01:47:44 +080094 if (!bitcode) {
95 mErrorCode = BCC_INVALID_VALUE;
96 LOGE("Invalid argument: bitcode = NULL\n");
97 return 1;
98 }
99
100 mSourceList[idx] = SourceInfo::createFromBuffer(resName,
101 bitcode, bitcodeSize,
102 flags);
103
104 if (!mSourceList[idx]) {
105 mErrorCode = BCC_OUT_OF_MEMORY;
106 LOGE("Out of memory while adding source bitcode\n");
107 return 1;
108 }
109
Loganecf4cbd2011-01-06 05:34:11 +0800110 return 0;
Logancf3e5212010-12-29 01:44:55 +0800111}
112
113
Logan474cbd22011-01-31 01:47:44 +0800114int Script::addSourceModule(size_t idx,
115 llvm::Module *module,
116 unsigned long flags) {
Logancf3e5212010-12-29 01:44:55 +0800117 if (mStatus != ScriptStatus::Unknown) {
118 mErrorCode = BCC_INVALID_OPERATION;
Logan474cbd22011-01-31 01:47:44 +0800119 LOGE("Bad operation: Adding source after bccPrepareExecutable\n");
Logancf3e5212010-12-29 01:44:55 +0800120 return 1;
121 }
122
Logan474cbd22011-01-31 01:47:44 +0800123 if (!module) {
124 mErrorCode = BCC_INVALID_VALUE;
125 LOGE("Invalid argument: module = NULL\n");
126 return 1;
127 }
128
129 mSourceList[idx] = SourceInfo::createFromModule(module, flags);
130
131 if (!mSourceList[idx]) {
132 mErrorCode = BCC_OUT_OF_MEMORY;
133 LOGE("Out of memory when add source module\n");
134 return 1;
135 }
136
Loganecf4cbd2011-01-06 05:34:11 +0800137 return 0;
Logancf3e5212010-12-29 01:44:55 +0800138}
139
140
Logan474cbd22011-01-31 01:47:44 +0800141int Script::addSourceFile(size_t idx,
142 char const *path,
143 unsigned long flags) {
Logan3133c412011-01-06 06:15:40 +0800144 if (mStatus != ScriptStatus::Unknown) {
Logancf3e5212010-12-29 01:44:55 +0800145 mErrorCode = BCC_INVALID_OPERATION;
Logan474cbd22011-01-31 01:47:44 +0800146 LOGE("Bad operation: Adding source after bccPrepareExecutable\n");
Logancf3e5212010-12-29 01:44:55 +0800147 return 1;
148 }
149
Logan474cbd22011-01-31 01:47:44 +0800150 if (!path) {
151 mErrorCode = BCC_INVALID_VALUE;
152 LOGE("Invalid argument: path = NULL\n");
153 return 1;
154 }
155
156 struct stat sb;
157 if (stat(path, &sb) != 0) {
158 mErrorCode = BCC_INVALID_VALUE;
159 LOGE("File not found: %s\n", path);
160 return 1;
161 }
162
163 mSourceList[idx] = SourceInfo::createFromFile(path, flags);
164
165 if (!mSourceList[idx]) {
166 mErrorCode = BCC_OUT_OF_MEMORY;
167 LOGE("Out of memory while adding source file\n");
168 return 1;
169 }
170
Logan3133c412011-01-06 06:15:40 +0800171 return 0;
Logancf3e5212010-12-29 01:44:55 +0800172}
173
174
Logan Chien311c26f2011-07-11 14:30:34 +0800175int Script::prepareExecutable(char const *cacheDir,
176 char const *cacheName,
177 unsigned long flags) {
Loganecf4cbd2011-01-06 05:34:11 +0800178 if (mStatus != ScriptStatus::Unknown) {
Logancf3e5212010-12-29 01:44:55 +0800179 mErrorCode = BCC_INVALID_OPERATION;
Loganecf4cbd2011-01-06 05:34:11 +0800180 LOGE("Invalid operation: %s\n", __func__);
Logancf3e5212010-12-29 01:44:55 +0800181 return 1;
182 }
183
Logan35849002011-01-15 07:30:43 +0800184#if USE_CACHE
Logan Chien311c26f2011-07-11 14:30:34 +0800185 if (cacheDir && cacheName) {
186 // Set Cache Directory and File Name
187 mCacheDir = cacheDir;
188 mCacheName = cacheName;
189
190 if (!mCacheDir.empty() && *mCacheDir.rbegin() != '/') {
191 mCacheDir.push_back('/'); // Ensure mCacheDir is end with '/'
192 }
193
194 // Load Cache File
195 if (internalLoadCache() == 0) {
196 return 0;
197 }
Logan033f46e2011-01-06 05:51:24 +0800198 }
Logan35849002011-01-15 07:30:43 +0800199#endif
Loganecf4cbd2011-01-06 05:34:11 +0800200
Stephen Hines27b35102011-05-11 17:58:48 -0700201 int status = internalCompile();
202 if (status != 0) {
203 LOGE("LLVM error message: %s\n", getCompilerErrorMessage());
204 }
205 return status;
Logan033f46e2011-01-06 05:51:24 +0800206}
207
208
Logan35849002011-01-15 07:30:43 +0800209#if USE_CACHE
Logan033f46e2011-01-06 05:51:24 +0800210int Script::internalLoadCache() {
Joseph Wen76919072011-07-07 23:06:15 -0700211 if (getBooleanProp("debug.bcc.nocache")) {
Logan033f46e2011-01-06 05:51:24 +0800212 // Android system environment property disable the cache mechanism by
213 // setting "debug.bcc.nocache". So we will not load the cache file any
214 // way.
215 return 1;
216 }
217
Logan Chien311c26f2011-07-11 14:30:34 +0800218 if (mCacheDir.empty() || mCacheName.empty()) {
Loganf340bf72011-01-14 17:51:40 +0800219 // The application developer has not specify the cachePath, so
Logan04329712011-01-06 06:10:57 +0800220 // we don't know where to open the cache file.
221 return 1;
Logan033f46e2011-01-06 05:51:24 +0800222 }
Logan04329712011-01-06 06:10:57 +0800223
Logan Chien311c26f2011-07-11 14:30:34 +0800224#if USE_OLD_JIT
Logan Chien03a2e302011-07-13 21:46:32 +0800225 std::string objPath(mCacheDir + mCacheName + ".jit-image");
226 std::string infoPath(mCacheDir + mCacheName + ".oBCC"); // TODO: .info instead
Logan Chien311c26f2011-07-11 14:30:34 +0800227#elif USE_MCJIT
228 std::string objPath(mCacheDir + mCacheName + ".o");
229 std::string infoPath(mCacheDir + mCacheName + ".info");
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700230#endif
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700231
Logan Chien311c26f2011-07-11 14:30:34 +0800232 FileHandle objFile;
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700233 if (objFile.open(objPath.c_str(), OpenMode::Read) < 0) {
Logan Chien03a2e302011-07-13 21:46:32 +0800234 // Unable to open the executable file in read mode.
Logan04329712011-01-06 06:10:57 +0800235 return 1;
236 }
237
Logan Chien311c26f2011-07-11 14:30:34 +0800238 FileHandle infoFile;
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700239 if (infoFile.open(infoPath.c_str(), OpenMode::Read) < 0) {
Logan Chien03a2e302011-07-13 21:46:32 +0800240 // Unable to open the metadata information file in read mode.
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700241 return 1;
242 }
243
Logan Chien311c26f2011-07-11 14:30:34 +0800244#if USE_OLD_JIT
245 CacheReader reader;
246#elif USE_MCJIT
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700247 MCCacheReader reader;
248
249 // Register symbol lookup function
250 if (mpExtSymbolLookupFn) {
251 reader.registerSymbolCallback(mpExtSymbolLookupFn,
252 mpExtSymbolLookupFnContext);
253 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700254#endif
Logan04329712011-01-06 06:10:57 +0800255
Logan9a5f8682011-01-07 06:09:57 +0800256 // Dependencies
Joseph Wen2ca6e572011-06-24 14:12:23 -0700257 reader.addDependency(BCC_FILE_RESOURCE, pathLibBCC_SHA1, sha1LibBCC_SHA1);
Joseph Wen76919072011-07-07 23:06:15 -0700258 reader.addDependency(BCC_FILE_RESOURCE, pathLibRS, sha1LibRS);
Logan9a5f8682011-01-07 06:09:57 +0800259
Logan474cbd22011-01-31 01:47:44 +0800260 for (size_t i = 0; i < 2; ++i) {
261 if (mSourceList[i]) {
262 mSourceList[i]->introDependency(reader);
263 }
Logan9a5f8682011-01-07 06:09:57 +0800264 }
265
266 // Read cache file
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700267 ScriptCached *cached = reader.readCacheFile(&objFile, &infoFile, this);
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700268
Logan04329712011-01-06 06:10:57 +0800269 if (!cached) {
Logan42598052011-01-26 22:41:13 +0800270 mIsContextSlotNotAvail = reader.isContextSlotNotAvail();
Logan04329712011-01-06 06:10:57 +0800271 return 1;
272 }
273
274 mCached = cached;
275 mStatus = ScriptStatus::Cached;
Logan033f46e2011-01-06 05:51:24 +0800276
Loganf3c83ce2011-01-07 06:36:33 +0800277 // Dirty hack for libRS.
278 // TODO(all): This dirty hack should be removed in the future.
Shih-wei Liao8eb5fe92011-02-01 04:17:38 -0800279 if (!cached->isLibRSThreadable() && mpExtSymbolLookupFn) {
Loganf3c83ce2011-01-07 06:36:33 +0800280 mpExtSymbolLookupFn(mpExtSymbolLookupFnContext, "__clearThreadable");
281 }
282
Loganf7f0ac52011-01-07 03:53:43 +0800283 return 0;
Logan033f46e2011-01-06 05:51:24 +0800284}
Logan35849002011-01-15 07:30:43 +0800285#endif
Logan033f46e2011-01-06 05:51:24 +0800286
Logan033f46e2011-01-06 05:51:24 +0800287int Script::internalCompile() {
288 // Create the ScriptCompiled object
Nowar Gu09b6c1c2011-05-24 23:49:07 +0800289 mCompiled = new (std::nothrow) ScriptCompiled(this);
Loganecf4cbd2011-01-06 05:34:11 +0800290
291 if (!mCompiled) {
292 mErrorCode = BCC_OUT_OF_MEMORY;
293 LOGE("Out of memory: %s %d\n", __FILE__, __LINE__);
294 return 1;
295 }
296
297 mStatus = ScriptStatus::Compiled;
298
Logan033f46e2011-01-06 05:51:24 +0800299 // Register symbol lookup function
Loganecf4cbd2011-01-06 05:34:11 +0800300 if (mpExtSymbolLookupFn) {
301 mCompiled->registerSymbolCallback(mpExtSymbolLookupFn,
302 mpExtSymbolLookupFnContext);
303 }
304
Logan474cbd22011-01-31 01:47:44 +0800305 // Parse Bitcode File (if necessary)
306 for (size_t i = 0; i < 2; ++i) {
307 if (mSourceList[i] && mSourceList[i]->prepareModule(mCompiled) != 0) {
308 LOGE("Unable to parse bitcode for source[%lu]\n", (unsigned long)i);
Logan033f46e2011-01-06 05:51:24 +0800309 return 1;
Loganecf4cbd2011-01-06 05:34:11 +0800310 }
Logan474cbd22011-01-31 01:47:44 +0800311 }
312
313 // Set the main source module
314 if (!mSourceList[0] || !mSourceList[0]->getModule()) {
315 LOGE("Source bitcode is not setted.\n");
316 return 1;
317 }
318
319 if (mCompiled->readModule(mSourceList[0]->takeModule()) != 0) {
320 LOGE("Unable to read source module\n");
321 return 1;
Loganecf4cbd2011-01-06 05:34:11 +0800322 }
323
Logan3133c412011-01-06 06:15:40 +0800324 // Link the source module with the library module
Logan474cbd22011-01-31 01:47:44 +0800325 if (mSourceList[1]) {
326 if (mCompiled->linkModule(mSourceList[1]->takeModule()) != 0) {
327 LOGE("Unable to link library module\n");
Logan04329712011-01-06 06:10:57 +0800328 return 1;
329 }
330 }
Loganecf4cbd2011-01-06 05:34:11 +0800331
Logan3133c412011-01-06 06:15:40 +0800332 // Compile and JIT the code
Logan04329712011-01-06 06:10:57 +0800333 if (mCompiled->compile() != 0) {
Logan65719812011-01-07 11:17:14 +0800334 LOGE("Unable to compile.\n");
Logan04329712011-01-06 06:10:57 +0800335 return 1;
336 }
337
Logan35849002011-01-15 07:30:43 +0800338#if USE_CACHE
Logan42598052011-01-26 22:41:13 +0800339 // Note: If we re-compile the script because the cached context slot not
340 // available, then we don't have to write the cache.
341
342 // Note: If the address of the context is not in the context slot, then
343 // we don't have to cache it.
344
Logan Chien311c26f2011-07-11 14:30:34 +0800345 if (!mCacheDir.empty() &&
346 !mCacheName.empty() &&
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700347#if USE_OLD_JIT
Logan1dc63142011-02-25 17:14:51 +0800348 !mIsContextSlotNotAvail &&
349 ContextManager::get().isManagingContext(getContext()) &&
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700350#endif
Logan42598052011-01-26 22:41:13 +0800351 !getBooleanProp("debug.bcc.nocache")) {
352
Logan Chien311c26f2011-07-11 14:30:34 +0800353#if USE_OLD_JIT
Logan Chien03a2e302011-07-13 21:46:32 +0800354 std::string objPath(mCacheDir + mCacheName + ".jit-image");
355 std::string infoPath(mCacheDir + mCacheName + ".oBCC");
Logan Chien311c26f2011-07-11 14:30:34 +0800356#elif USE_MCJIT
Logan Chien311c26f2011-07-11 14:30:34 +0800357 std::string objPath(mCacheDir + mCacheName + ".o");
358 std::string infoPath(mCacheDir + mCacheName + ".info");
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700359#endif
Logan04329712011-01-06 06:10:57 +0800360
Logan Chien311c26f2011-07-11 14:30:34 +0800361
Jeff Brown937a0bc2011-01-26 23:20:14 -0800362 // Remove the file if it already exists before writing the new file.
363 // The old file may still be mapped elsewhere in memory and we do not want
364 // to modify its contents. (The same script may be running concurrently in
365 // the same process or a different process!)
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700366 ::unlink(objPath.c_str());
Logan Chien311c26f2011-07-11 14:30:34 +0800367#if !USE_OLD_JIT && USE_MCJIT
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700368 ::unlink(infoPath.c_str());
369#endif
Jeff Brown937a0bc2011-01-26 23:20:14 -0800370
Logan Chien03a2e302011-07-13 21:46:32 +0800371 FileHandle objFile;
372 FileHandle infoFile;
373
374 if (objFile.open(objPath.c_str(), OpenMode::Write) >= 0 &&
375 infoFile.open(infoPath.c_str(), OpenMode::Write) >= 0) {
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700376
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700377#if USE_OLD_JIT
Logan04329712011-01-06 06:10:57 +0800378 CacheWriter writer;
Logan Chien311c26f2011-07-11 14:30:34 +0800379#elif USE_MCJIT
380 MCCacheWriter writer;
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700381#endif
Logana27a83f2011-01-07 10:25:48 +0800382
Joseph Wen2ca6e572011-06-24 14:12:23 -0700383#ifdef TARGET_BUILD
Logana2e15af2011-01-07 11:46:08 +0800384 // Dependencies
Joseph Wen2ca6e572011-06-24 14:12:23 -0700385 writer.addDependency(BCC_FILE_RESOURCE, pathLibBCC_SHA1, sha1LibBCC_SHA1);
Joseph Wen76919072011-07-07 23:06:15 -0700386 writer.addDependency(BCC_FILE_RESOURCE, pathLibRS, sha1LibRS);
Logane1323992011-01-12 04:47:13 +0800387#endif
Logana2e15af2011-01-07 11:46:08 +0800388
Logan474cbd22011-01-31 01:47:44 +0800389 for (size_t i = 0; i < 2; ++i) {
Logan825c3b22011-02-28 05:05:48 +0800390 if (mSourceList[i]) {
391 mSourceList[i]->introDependency(writer);
392 }
Logana2e15af2011-01-07 11:46:08 +0800393 }
394
Logana27a83f2011-01-07 10:25:48 +0800395 // libRS is threadable dirty hack
396 // TODO: This should be removed in the future
397 uint32_t libRS_threadable = 0;
398 if (mpExtSymbolLookupFn) {
Logan89eb47f2011-01-07 10:45:16 +0800399 libRS_threadable =
400 (uint32_t)mpExtSymbolLookupFn(mpExtSymbolLookupFnContext,
401 "__isThreadable");
Logana27a83f2011-01-07 10:25:48 +0800402 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700403
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700404 if (!writer.writeCacheFile(&objFile, &infoFile, this, libRS_threadable)) {
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700405 objFile.truncate();
406 objFile.close();
Logana27a83f2011-01-07 10:25:48 +0800407
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700408 if (unlink(objPath.c_str()) != 0) {
Logan89eb47f2011-01-07 10:45:16 +0800409 LOGE("Unable to remove the invalid cache file: %s. (reason: %s)\n",
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700410 objPath.c_str(), strerror(errno));
Logan89eb47f2011-01-07 10:45:16 +0800411 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700412
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700413 infoFile.truncate();
414 infoFile.close();
415
416 if (unlink(infoPath.c_str()) != 0) {
417 LOGE("Unable to remove the invalid cache file: %s. (reason: %s)\n",
418 infoPath.c_str(), strerror(errno));
419 }
Logan89eb47f2011-01-07 10:45:16 +0800420 }
421 }
Logan04329712011-01-06 06:10:57 +0800422 }
Logan35849002011-01-15 07:30:43 +0800423#endif // USE_CACHE
Logan04329712011-01-06 06:10:57 +0800424
425 return 0;
Logancf3e5212010-12-29 01:44:55 +0800426}
427
428
429char const *Script::getCompilerErrorMessage() {
430 if (mStatus != ScriptStatus::Compiled) {
431 mErrorCode = BCC_INVALID_OPERATION;
432 return NULL;
433 }
434
435 return mCompiled->getCompilerErrorMessage();
436}
437
438
439void *Script::lookup(const char *name) {
Logan89eb47f2011-01-07 10:45:16 +0800440 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700441 case ScriptStatus::Compiled: {
442 return mCompiled->lookup(name);
443 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700444
Logan35849002011-01-15 07:30:43 +0800445#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700446 case ScriptStatus::Cached: {
447 return mCached->lookup(name);
448 }
Logan35849002011-01-15 07:30:43 +0800449#endif
Logan89eb47f2011-01-07 10:45:16 +0800450
Shih-wei Liaod50be322011-07-01 22:53:31 -0700451 default: {
452 mErrorCode = BCC_INVALID_OPERATION;
453 return NULL;
454 }
Logancf3e5212010-12-29 01:44:55 +0800455 }
Logancf3e5212010-12-29 01:44:55 +0800456}
457
458
Loganbe79ada2011-01-13 01:33:45 +0800459size_t Script::getExportVarCount() const {
Logan89eb47f2011-01-07 10:45:16 +0800460 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700461 case ScriptStatus::Compiled: {
462 return mCompiled->getExportVarCount();
463 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700464
Logan35849002011-01-15 07:30:43 +0800465#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700466 case ScriptStatus::Cached: {
467 return mCached->getExportVarCount();
468 }
Logan35849002011-01-15 07:30:43 +0800469#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700470
Shih-wei Liaod50be322011-07-01 22:53:31 -0700471 default: {
472 return 0;
473 }
Loganbe79ada2011-01-13 01:33:45 +0800474 }
475}
476
477
478size_t Script::getExportFuncCount() const {
479 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700480 case ScriptStatus::Compiled: {
481 return mCompiled->getExportFuncCount();
482 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700483
Logan35849002011-01-15 07:30:43 +0800484#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700485 case ScriptStatus::Cached: {
486 return mCached->getExportFuncCount();
487 }
Logan35849002011-01-15 07:30:43 +0800488#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700489
Shih-wei Liaod50be322011-07-01 22:53:31 -0700490 default: {
491 return 0;
492 }
Loganbe79ada2011-01-13 01:33:45 +0800493 }
494}
495
496
497size_t Script::getPragmaCount() const {
498 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700499 case ScriptStatus::Compiled: {
500 return mCompiled->getPragmaCount();
501 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700502
Logan35849002011-01-15 07:30:43 +0800503#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700504 case ScriptStatus::Cached: {
505 return mCached->getPragmaCount();
506 }
Logan35849002011-01-15 07:30:43 +0800507#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700508
Shih-wei Liaod50be322011-07-01 22:53:31 -0700509 default: {
510 return 0;
511 }
Loganbe79ada2011-01-13 01:33:45 +0800512 }
513}
514
515
516size_t Script::getFuncCount() const {
517 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700518 case ScriptStatus::Compiled: {
519 return mCompiled->getFuncCount();
520 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700521
Logan35849002011-01-15 07:30:43 +0800522#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700523 case ScriptStatus::Cached: {
524 return mCached->getFuncCount();
525 }
Logan35849002011-01-15 07:30:43 +0800526#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700527
Shih-wei Liaod50be322011-07-01 22:53:31 -0700528 default: {
529 return 0;
530 }
Loganbe79ada2011-01-13 01:33:45 +0800531 }
532}
533
534
Stephen Hines071288a2011-01-27 14:38:26 -0800535size_t Script::getObjectSlotCount() const {
536 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700537 case ScriptStatus::Compiled: {
538 return mCompiled->getObjectSlotCount();
539 }
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700540
Stephen Hines071288a2011-01-27 14:38:26 -0800541#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700542 case ScriptStatus::Cached: {
543 return mCached->getObjectSlotCount();
544 }
Stephen Hines071288a2011-01-27 14:38:26 -0800545#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700546
Shih-wei Liaod50be322011-07-01 22:53:31 -0700547 default: {
548 return 0;
549 }
Stephen Hines071288a2011-01-27 14:38:26 -0800550 }
551}
552
553
Loganbe79ada2011-01-13 01:33:45 +0800554void Script::getExportVarList(size_t varListSize, void **varList) {
555 switch (mStatus) {
556#define DELEGATE(STATUS) \
Shih-wei Liaod50be322011-07-01 22:53:31 -0700557 case ScriptStatus::STATUS: \
558 m##STATUS->getExportVarList(varListSize, varList); \
559 break;
Logancf3e5212010-12-29 01:44:55 +0800560
Logan35849002011-01-15 07:30:43 +0800561#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700562 DELEGATE(Cached);
Logan35849002011-01-15 07:30:43 +0800563#endif
564
Shih-wei Liaod50be322011-07-01 22:53:31 -0700565 DELEGATE(Compiled);
Loganbe79ada2011-01-13 01:33:45 +0800566#undef DELEGATE
Logan89eb47f2011-01-07 10:45:16 +0800567
Shih-wei Liaod50be322011-07-01 22:53:31 -0700568 default: {
569 mErrorCode = BCC_INVALID_OPERATION;
570 }
Logan89eb47f2011-01-07 10:45:16 +0800571 }
Logancf3e5212010-12-29 01:44:55 +0800572}
573
Joseph Wenf36637f2011-07-06 18:27:12 -0700574void Script::getExportVarNameList(std::vector<std::string> &varList) {
575 switch (mStatus) {
576 case ScriptStatus::Compiled: {
577 return mCompiled->getExportVarNameList(varList);
578 }
579
580 default: {
581 mErrorCode = BCC_INVALID_OPERATION;
582 }
583 }
584}
585
Logancf3e5212010-12-29 01:44:55 +0800586
Loganbe79ada2011-01-13 01:33:45 +0800587void Script::getExportFuncList(size_t funcListSize, void **funcList) {
Logan89eb47f2011-01-07 10:45:16 +0800588 switch (mStatus) {
Loganbe79ada2011-01-13 01:33:45 +0800589#define DELEGATE(STATUS) \
Shih-wei Liaod50be322011-07-01 22:53:31 -0700590 case ScriptStatus::STATUS: \
591 m##STATUS->getExportFuncList(funcListSize, funcList); \
592 break;
Logancf3e5212010-12-29 01:44:55 +0800593
Logan35849002011-01-15 07:30:43 +0800594#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700595 DELEGATE(Cached);
Logan35849002011-01-15 07:30:43 +0800596#endif
597
Shih-wei Liaod50be322011-07-01 22:53:31 -0700598 DELEGATE(Compiled);
Loganbe79ada2011-01-13 01:33:45 +0800599#undef DELEGATE
Logan89eb47f2011-01-07 10:45:16 +0800600
Shih-wei Liaod50be322011-07-01 22:53:31 -0700601 default: {
602 mErrorCode = BCC_INVALID_OPERATION;
603 }
Logan89eb47f2011-01-07 10:45:16 +0800604 }
Logancf3e5212010-12-29 01:44:55 +0800605}
606
Joseph Wenf36637f2011-07-06 18:27:12 -0700607void Script::getExportFuncNameList(std::vector<std::string> &funcList) {
608 switch (mStatus) {
609 case ScriptStatus::Compiled: {
610 return mCompiled->getExportFuncNameList(funcList);
611 }
612
613 default: {
614 mErrorCode = BCC_INVALID_OPERATION;
615 }
616 }
617}
618
Logancf3e5212010-12-29 01:44:55 +0800619
Loganbe79ada2011-01-13 01:33:45 +0800620void Script::getPragmaList(size_t pragmaListSize,
621 char const **keyList,
622 char const **valueList) {
Logan89eb47f2011-01-07 10:45:16 +0800623 switch (mStatus) {
Loganbe79ada2011-01-13 01:33:45 +0800624#define DELEGATE(STATUS) \
Shih-wei Liaod50be322011-07-01 22:53:31 -0700625 case ScriptStatus::STATUS: \
626 m##STATUS->getPragmaList(pragmaListSize, keyList, valueList); \
627 break;
Logancf3e5212010-12-29 01:44:55 +0800628
Logan35849002011-01-15 07:30:43 +0800629#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700630 DELEGATE(Cached);
Logan35849002011-01-15 07:30:43 +0800631#endif
632
Shih-wei Liaod50be322011-07-01 22:53:31 -0700633 DELEGATE(Compiled);
Loganbe79ada2011-01-13 01:33:45 +0800634#undef DELEGATE
Logan89eb47f2011-01-07 10:45:16 +0800635
Shih-wei Liaod50be322011-07-01 22:53:31 -0700636 default: {
637 mErrorCode = BCC_INVALID_OPERATION;
638 }
Logan89eb47f2011-01-07 10:45:16 +0800639 }
Logancf3e5212010-12-29 01:44:55 +0800640}
641
642
Loganf340bf72011-01-14 17:51:40 +0800643void Script::getFuncInfoList(size_t funcInfoListSize,
644 FuncInfo *funcInfoList) {
Logan89eb47f2011-01-07 10:45:16 +0800645 switch (mStatus) {
Loganbe79ada2011-01-13 01:33:45 +0800646#define DELEGATE(STATUS) \
Shih-wei Liaod50be322011-07-01 22:53:31 -0700647 case ScriptStatus::STATUS: \
648 m##STATUS->getFuncInfoList(funcInfoListSize, funcInfoList); \
649 break;
Logancf3e5212010-12-29 01:44:55 +0800650
Logan35849002011-01-15 07:30:43 +0800651#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700652 DELEGATE(Cached);
Logan35849002011-01-15 07:30:43 +0800653#endif
654
Shih-wei Liaod50be322011-07-01 22:53:31 -0700655 DELEGATE(Compiled);
Loganbe79ada2011-01-13 01:33:45 +0800656#undef DELEGATE
Logan89eb47f2011-01-07 10:45:16 +0800657
Shih-wei Liaod50be322011-07-01 22:53:31 -0700658 default: {
659 mErrorCode = BCC_INVALID_OPERATION;
660 }
Logan89eb47f2011-01-07 10:45:16 +0800661 }
Logancf3e5212010-12-29 01:44:55 +0800662}
663
Stephen Hines071288a2011-01-27 14:38:26 -0800664
665void Script::getObjectSlotList(size_t objectSlotListSize,
666 uint32_t *objectSlotList) {
667 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700668#define DELEGATE(STATUS) \
669 case ScriptStatus::STATUS: \
670 m##STATUS->getObjectSlotList(objectSlotListSize, objectSlotList); \
671 break;
Stephen Hines071288a2011-01-27 14:38:26 -0800672
673#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700674 DELEGATE(Cached);
Stephen Hines071288a2011-01-27 14:38:26 -0800675#endif
676
Shih-wei Liaod50be322011-07-01 22:53:31 -0700677 DELEGATE(Compiled);
Stephen Hines071288a2011-01-27 14:38:26 -0800678#undef DELEGATE
679
Shih-wei Liaod50be322011-07-01 22:53:31 -0700680 default: {
681 mErrorCode = BCC_INVALID_OPERATION;
682 }
Stephen Hines071288a2011-01-27 14:38:26 -0800683 }
684}
685
686
Logana27a83f2011-01-07 10:25:48 +0800687char *Script::getContext() {
688 switch (mStatus) {
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700689
Logan35849002011-01-15 07:30:43 +0800690#if USE_CACHE
Shih-wei Liaod50be322011-07-01 22:53:31 -0700691 case ScriptStatus::Cached: {
692 return mCached->getContext();
693 }
Logan35849002011-01-15 07:30:43 +0800694#endif
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700695
Shih-wei Liaod50be322011-07-01 22:53:31 -0700696 case ScriptStatus::Compiled: {
697 return mCompiled->getContext();
698 }
Logana27a83f2011-01-07 10:25:48 +0800699
Shih-wei Liaod50be322011-07-01 22:53:31 -0700700 default: {
701 mErrorCode = BCC_INVALID_OPERATION;
702 return NULL;
703 }
Logan02286cb2011-01-07 00:30:47 +0800704 }
Logan02286cb2011-01-07 00:30:47 +0800705}
706
Logancf3e5212010-12-29 01:44:55 +0800707
Shih-wei Liaoce82d492011-01-20 12:34:03 -0800708int Script::registerSymbolCallback(BCCSymbolLookupFn pFn, void *pContext) {
Logancf3e5212010-12-29 01:44:55 +0800709 mpExtSymbolLookupFn = pFn;
710 mpExtSymbolLookupFnContext = pContext;
711
Logan7d2219f2011-01-06 06:19:25 +0800712 if (mStatus != ScriptStatus::Unknown) {
Logancf3e5212010-12-29 01:44:55 +0800713 mErrorCode = BCC_INVALID_OPERATION;
Logan7d2219f2011-01-06 06:19:25 +0800714 LOGE("Invalid operation: %s\n", __func__);
Shih-wei Liaoce82d492011-01-20 12:34:03 -0800715 return 1;
Logancf3e5212010-12-29 01:44:55 +0800716 }
Shih-wei Liaoce82d492011-01-20 12:34:03 -0800717 return 0;
Logancf3e5212010-12-29 01:44:55 +0800718}
Shih-wei Liaob65410d2011-06-19 11:11:48 -0700719
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700720#if USE_MCJIT
721size_t Script::getELFSize() const {
722 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700723 case ScriptStatus::Compiled: {
724 return mCompiled->getELFSize();
725 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700726
Shih-wei Liaod50be322011-07-01 22:53:31 -0700727 default: {
728 return 0;
729 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700730 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700731}
732
733const char *Script::getELF() const {
734 switch (mStatus) {
Shih-wei Liaod50be322011-07-01 22:53:31 -0700735 case ScriptStatus::Compiled: {
736 return mCompiled->getELF();
737 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700738
Shih-wei Liaod50be322011-07-01 22:53:31 -0700739 default: {
740 return NULL;
741 }
Shih-wei Liao5e3e0ce2011-06-17 13:59:46 -0700742 }
743}
744#endif
Logancf3e5212010-12-29 01:44:55 +0800745
746} // namespace bcc