Revert "Start chewing new libbcc APIs."
This reverts commit ec3fc1163c01e18b1454057723c451f0d96868ad.
diff --git a/driver/rsdBcc.cpp b/driver/rsdBcc.cpp
index d9b5212..7dd2d2b 100644
--- a/driver/rsdBcc.cpp
+++ b/driver/rsdBcc.cpp
@@ -18,16 +18,12 @@
#include "rsdBcc.h"
#include "rsdRuntime.h"
-#include <bcc/BCCContext.h>
-#include <bcc/RenderScript/RSCompilerDriver.h>
-#include <bcc/RenderScript/RSExecutable.h>
-#include <bcc/RenderScript/RSInfo.h>
+#include <bcinfo/MetadataExtractor.h>
#include "rsContext.h"
#include "rsElement.h"
#include "rsScriptC.h"
-#include "utils/Vector.h"
#include "utils/Timers.h"
#include "utils/StopWatch.h"
@@ -40,9 +36,18 @@
void (*mInit)();
void (*mFreeChildren)();
- bcc::BCCContext *mCompilerContext;
- bcc::RSCompilerDriver *mCompilerDriver;
- bcc::RSExecutable *mExecutable;
+ BCCScriptRef mBccScript;
+
+ bcinfo::MetadataExtractor *ME;
+
+ InvokeFunc_t *mInvokeFunctions;
+ ForEachFunc_t *mForEachFunctions;
+ void ** mFieldAddress;
+ bool * mFieldIsObject;
+ const uint32_t *mExportForEachSignatureList;
+
+ const uint8_t * mScriptText;
+ uint32_t mScriptTextLength;
};
typedef void (*outer_foreach_t)(
@@ -70,72 +75,112 @@
pthread_mutex_lock(&rsdgInitMutex);
- bcc::RSExecutable *exec;
- const bcc::RSInfo *info;
+ size_t exportFuncCount = 0;
+ size_t exportVarCount = 0;
+ size_t objectSlotCount = 0;
+ size_t exportForEachSignatureCount = 0;
+
DrvScript *drv = (DrvScript *)calloc(1, sizeof(DrvScript));
if (drv == NULL) {
goto error;
}
script->mHal.drv = drv;
- drv->mCompilerContext = NULL;
- drv->mCompilerDriver = NULL;
- drv->mExecutable = NULL;
-
- drv->mCompilerContext = new bcc::BCCContext();
- if (drv->mCompilerContext == NULL) {
- ALOGE("bcc: FAILS to create compiler context (out of memory)");
- goto error;
- }
-
- drv->mCompilerDriver = new bcc::RSCompilerDriver();
- if (drv->mCompilerDriver == NULL) {
- ALOGE("bcc: FAILS to create compiler driver (out of memory)");
- goto error;
- }
-
+ drv->mBccScript = bccCreateScript();
script->mHal.info.isThreadable = true;
+ drv->mScriptText = bitcode;
+ drv->mScriptTextLength = bitcodeSize;
- drv->mCompilerDriver->setRSRuntimeLookupFunction(rsdLookupRuntimeStub);
- drv->mCompilerDriver->setRSRuntimeLookupContext(script);
- exec = drv->mCompilerDriver->build(*drv->mCompilerContext,
- cacheDir, resName,
- (const char *)bitcode, bitcodeSize);
+ drv->ME = new bcinfo::MetadataExtractor((const char*)drv->mScriptText,
+ drv->mScriptTextLength);
+ if (!drv->ME->extract()) {
+ ALOGE("bcinfo: failed to read script metadata");
+ goto error;
+ }
- if (exec == NULL) {
- ALOGE("bcc: FAILS to prepare executable for '%s'", resName);
+ //ALOGE("mBccScript %p", script->mBccScript);
+
+ if (bccRegisterSymbolCallback(drv->mBccScript, &rsdLookupRuntimeStub, script) != 0) {
+ ALOGE("bcc: FAILS to register symbol callback");
goto error;
}
- drv->mExecutable = exec;
-
- exec->setThreadable(script->mHal.info.isThreadable);
- if (!exec->syncInfo()) {
- ALOGW("bcc: FAILS to synchronize the RS info file to the disk");
+ if (bccReadBC(drv->mBccScript,
+ resName,
+ (char const *)drv->mScriptText,
+ drv->mScriptTextLength, 0) != 0) {
+ ALOGE("bcc: FAILS to read bitcode");
+ goto error;
}
- drv->mRoot = reinterpret_cast<int (*)()>(exec->getSymbolAddress("root"));
- drv->mRootExpand =
- reinterpret_cast<int (*)()>(exec->getSymbolAddress("root.expand"));
- drv->mInit = reinterpret_cast<void (*)()>(exec->getSymbolAddress("init"));
- drv->mFreeChildren =
- reinterpret_cast<void (*)()>(exec->getSymbolAddress(".rs.dtor"));
+ if (bccLinkFile(drv->mBccScript, "/system/lib/libclcore.bc", 0) != 0) {
+ ALOGE("bcc: FAILS to link bitcode");
+ goto error;
+ }
- info = &drv->mExecutable->getInfo();
+ if (bccPrepareExecutable(drv->mBccScript, cacheDir, resName, 0) != 0) {
+ ALOGE("bcc: FAILS to prepare executable");
+ goto error;
+ }
+
+ drv->mRoot = reinterpret_cast<int (*)()>(bccGetFuncAddr(drv->mBccScript, "root"));
+ drv->mRootExpand = reinterpret_cast<int (*)()>(bccGetFuncAddr(drv->mBccScript, "root.expand"));
+ drv->mInit = reinterpret_cast<void (*)()>(bccGetFuncAddr(drv->mBccScript, "init"));
+ drv->mFreeChildren = reinterpret_cast<void (*)()>(bccGetFuncAddr(drv->mBccScript, ".rs.dtor"));
+
+ exportFuncCount = drv->ME->getExportFuncCount();
+ if (exportFuncCount > 0) {
+ drv->mInvokeFunctions = (InvokeFunc_t*) calloc(exportFuncCount,
+ sizeof(InvokeFunc_t));
+ bccGetExportFuncList(drv->mBccScript, exportFuncCount,
+ (void **) drv->mInvokeFunctions);
+ } else {
+ drv->mInvokeFunctions = NULL;
+ }
+
+ exportVarCount = drv->ME->getExportVarCount();
+ if (exportVarCount > 0) {
+ drv->mFieldAddress = (void **) calloc(exportVarCount, sizeof(void*));
+ drv->mFieldIsObject = (bool *) calloc(exportVarCount, sizeof(bool));
+ bccGetExportVarList(drv->mBccScript, exportVarCount,
+ (void **) drv->mFieldAddress);
+ } else {
+ drv->mFieldAddress = NULL;
+ drv->mFieldIsObject = NULL;
+ }
+
+ objectSlotCount = drv->ME->getObjectSlotCount();
+ if (objectSlotCount > 0) {
+ const uint32_t *objectSlotList = drv->ME->getObjectSlotList();
+ for (uint32_t ct=0; ct < objectSlotCount; ct++) {
+ drv->mFieldIsObject[objectSlotList[ct]] = true;
+ }
+ }
+
+ exportForEachSignatureCount = drv->ME->getExportForEachSignatureCount();
+ drv->mExportForEachSignatureList = drv->ME->getExportForEachSignatureList();
+ if (exportForEachSignatureCount > 0) {
+ drv->mForEachFunctions =
+ (ForEachFunc_t*) calloc(exportForEachSignatureCount,
+ sizeof(ForEachFunc_t));
+ bccGetExportForEachList(drv->mBccScript, exportForEachSignatureCount,
+ (void **) drv->mForEachFunctions);
+ } else {
+ drv->mForEachFunctions = NULL;
+ }
+
// Copy info over to runtime
- script->mHal.info.exportedFunctionCount = info->getExportFuncNames().size();
- script->mHal.info.exportedVariableCount = info->getExportVarNames().size();
- script->mHal.info.exportedPragmaCount = info->getPragmas().size();
- script->mHal.info.exportedPragmaKeyList =
- const_cast<const char**>(exec->getPragmaKeys().array());
- script->mHal.info.exportedPragmaValueList =
- const_cast<const char**>(exec->getPragmaValues().array());
+ script->mHal.info.exportedFunctionCount = drv->ME->getExportFuncCount();
+ script->mHal.info.exportedVariableCount = drv->ME->getExportVarCount();
+ script->mHal.info.exportedPragmaCount = drv->ME->getPragmaCount();
+ script->mHal.info.exportedPragmaKeyList = drv->ME->getPragmaKeyList();
+ script->mHal.info.exportedPragmaValueList = drv->ME->getPragmaValueList();
if (drv->mRootExpand) {
- script->mHal.info.root = drv->mRootExpand;
+ script->mHal.info.root = drv->mRootExpand;
} else {
- script->mHal.info.root = drv->mRoot;
+ script->mHal.info.root = drv->mRoot;
}
pthread_mutex_unlock(&rsdgInitMutex);
@@ -144,13 +189,11 @@
error:
pthread_mutex_unlock(&rsdgInitMutex);
- if (drv) {
- delete drv->mCompilerContext;
- delete drv->mCompilerDriver;
- delete drv->mExecutable;
- free(drv);
+ if (drv->ME) {
+ delete drv->ME;
+ drv->ME = NULL;
}
- script->mHal.drv = NULL;
+ free(drv);
return false;
}
@@ -264,12 +307,12 @@
memset(&mtls, 0, sizeof(mtls));
DrvScript *drv = (DrvScript *)s->mHal.drv;
- rsAssert(slot < drv->mExecutable->getExportForeachFuncAddrs().size());
- mtls.kernel = reinterpret_cast<ForEachFunc_t>(
- drv->mExecutable->getExportForeachFuncAddrs()[slot]);
+ mtls.kernel = drv->mForEachFunctions[slot];
rsAssert(mtls.kernel != NULL);
- mtls.sig = drv->mExecutable->getInfo().getExportForeachFuncs()[slot].second;
-
+ mtls.sig = 0x1f; // temp fix for old apps, full table in slang_rs_export_foreach.cpp
+ if (drv->mExportForEachSignatureList) {
+ mtls.sig = drv->mExportForEachSignatureList[slot];
+ }
if (ain) {
mtls.dimX = ain->getType()->getDimX();
mtls.dimY = ain->getType()->getDimY();
@@ -412,8 +455,8 @@
//ALOGE("invoke %p %p %i %p %i", dc, script, slot, params, paramLength);
Script * oldTLS = setTLS(script);
- reinterpret_cast<void (*)(const void *, uint32_t)>(
- drv->mExecutable->getExportFuncAddrs()[slot])(params, paramLength);
+ ((void (*)(const void *, uint32_t))
+ drv->mInvokeFunctions[slot])(params, paramLength);
setTLS(oldTLS);
}
@@ -423,8 +466,7 @@
//rsAssert(!script->mFieldIsObject[slot]);
//ALOGE("setGlobalVar %p %p %i %p %i", dc, script, slot, data, dataLength);
- int32_t *destPtr = reinterpret_cast<int32_t *>(
- drv->mExecutable->getExportVarAddrs()[slot]);
+ int32_t *destPtr = ((int32_t **)drv->mFieldAddress)[slot];
if (!destPtr) {
//ALOGV("Calling setVar on slot = %i which is null", slot);
return;
@@ -479,8 +521,7 @@
//rsAssert(!script->mFieldIsObject[slot]);
//ALOGE("setGlobalBind %p %p %i %p", dc, script, slot, data);
- int32_t *destPtr = reinterpret_cast<int32_t *>(
- drv->mExecutable->getExportVarAddrs()[slot]);
+ int32_t *destPtr = ((int32_t **)drv->mFieldAddress)[slot];
if (!destPtr) {
//ALOGV("Calling setVar on slot = %i which is null", slot);
return;
@@ -494,8 +535,7 @@
//rsAssert(script->mFieldIsObject[slot]);
//ALOGE("setGlobalObj %p %p %i %p", dc, script, slot, data);
- int32_t *destPtr = reinterpret_cast<int32_t *>(
- drv->mExecutable->getExportVarAddrs()[slot]);
+ int32_t *destPtr = ((int32_t **)drv->mFieldAddress)[slot];
if (!destPtr) {
//ALOGV("Calling setVar on slot = %i which is null", slot);
return;
@@ -507,43 +547,38 @@
void rsdScriptDestroy(const Context *dc, Script *script) {
DrvScript *drv = (DrvScript *)script->mHal.drv;
- if (drv == NULL) {
- return;
- }
-
- if (drv->mExecutable) {
- Vector<void *>::const_iterator var_addr_iter =
- drv->mExecutable->getExportVarAddrs().begin();
- Vector<void *>::const_iterator var_addr_end =
- drv->mExecutable->getExportVarAddrs().end();
-
- bcc::RSInfo::ObjectSlotListTy::const_iterator is_object_iter =
- drv->mExecutable->getInfo().getObjectSlots().begin();
- bcc::RSInfo::ObjectSlotListTy::const_iterator is_object_end =
- drv->mExecutable->getInfo().getObjectSlots().end();
-
- while ((var_addr_iter != var_addr_end) &&
- (is_object_iter != is_object_end)) {
- // The field address can be NULL if the script-side has optimized
- // the corresponding global variable away.
- ObjectBase **obj_addr =
- reinterpret_cast<ObjectBase **>(*var_addr_iter);
- if (*is_object_iter) {
- if (*var_addr_iter != NULL) {
- rsrClearObject(dc, script, obj_addr);
+ if (drv->mFieldAddress) {
+ size_t exportVarCount = drv->ME->getExportVarCount();
+ for (size_t ct = 0; ct < exportVarCount; ct++) {
+ if (drv->mFieldIsObject[ct]) {
+ // The field address can be NULL if the script-side has
+ // optimized the corresponding global variable away.
+ if (drv->mFieldAddress[ct]) {
+ rsrClearObject(dc, script, (ObjectBase **)drv->mFieldAddress[ct]);
}
}
- var_addr_iter++;
- is_object_iter++;
}
+ free(drv->mFieldAddress);
+ drv->mFieldAddress = NULL;
+ free(drv->mFieldIsObject);
+ drv->mFieldIsObject = NULL; }
+
+ if (drv->mInvokeFunctions) {
+ free(drv->mInvokeFunctions);
+ drv->mInvokeFunctions = NULL;
}
- delete drv->mCompilerContext;
- delete drv->mCompilerDriver;
- delete drv->mExecutable;
+ if (drv->mForEachFunctions) {
+ free(drv->mForEachFunctions);
+ drv->mForEachFunctions = NULL;
+ }
+
+ delete drv->ME;
+ drv->ME = NULL;
free(drv);
script->mHal.drv = NULL;
+
}
