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;
+
 }