Reduce diffs with compat lib.

Change-Id: Ibfa2c7c7da56d158f424ac343e364feacd0a21da

9 files changed, 466 insertions, 192 deletions

diff --git a/cpu_ref/rsCpuRuntimeMath.cpp b/cpu_ref/rsCpuRuntimeMath.cpp
index b72565b1..f66677b8 100644
--- a/cpu_ref/rsCpuRuntimeMath.cpp
+++ b/cpu_ref/rsCpuRuntimeMath.cpp
@@ -80,13 +80,6 @@ static void SC_MatrixTranspose_2x2(Matrix2x2 *m) {
     m->transpose();
 }
 
-static float SC_randf(float max) {
-    float r = (float)rand();
-    r *= max;
-    r /= RAND_MAX;
-    return r;
-}
-
 static float SC_randf2(float min, float max) {
     float r = (float)rand();
     r /= RAND_MAX;
@@ -94,121 +87,12 @@ static float SC_randf2(float min, float max) {
     return r;
 }
 
-static int SC_randi(int max) {
-    return (int)SC_randf(max);
-}
-
-static int SC_randi2(int min, int max) {
-    return (int)SC_randf2(min, max);
-}
-
 static float SC_frac(float v) {
     int i = (int)floor(v);
     return fmin(v - i, 0x1.fffffep-1f);
 }
 
 
-static int32_t SC_AtomicCas(volatile int32_t *ptr, int32_t expectedValue, int32_t newValue) {
-    int32_t prev;
-
-    do {
-        int32_t ret = android_atomic_release_cas(expectedValue, newValue, ptr);
-        if (!ret) {
-            // The android cas return 0 if it wrote the value.  This means the
-            // previous value was the expected value and we can return.
-            return expectedValue;
-        }
-        // We didn't write the value and need to load the "previous" value.
-        prev = *ptr;
-
-        // A race condition exists where the expected value could appear after our cas failed
-        // above.  In this case loop until we have a legit previous value or the
-        // write passes.
-        } while (prev == expectedValue);
-    return prev;
-}
-
-
-static int32_t SC_AtomicInc(volatile int32_t *ptr) {
-    return android_atomic_inc(ptr);
-}
-
-static int32_t SC_AtomicDec(volatile int32_t *ptr) {
-    return android_atomic_dec(ptr);
-}
-
-static int32_t SC_AtomicAdd(volatile int32_t *ptr, int32_t value) {
-    return android_atomic_add(value, ptr);
-}
-
-static int32_t SC_AtomicSub(volatile int32_t *ptr, int32_t value) {
-    int32_t prev, status;
-    do {
-        prev = *ptr;
-        status = android_atomic_release_cas(prev, prev - value, ptr);
-    } while (CC_UNLIKELY(status != 0));
-    return prev;
-}
-
-static int32_t SC_AtomicAnd(volatile int32_t *ptr, int32_t value) {
-    return android_atomic_and(value, ptr);
-}
-
-static int32_t SC_AtomicOr(volatile int32_t *ptr, int32_t value) {
-    return android_atomic_or(value, ptr);
-}
-
-static int32_t SC_AtomicXor(volatile int32_t *ptr, int32_t value) {
-    int32_t prev, status;
-    do {
-        prev = *ptr;
-        status = android_atomic_release_cas(prev, prev ^ value, ptr);
-    } while (CC_UNLIKELY(status != 0));
-    return prev;
-}
-
-static uint32_t SC_AtomicUMin(volatile uint32_t *ptr, uint32_t value) {
-    uint32_t prev, status;
-    do {
-        prev = *ptr;
-        uint32_t n = rsMin(value, prev);
-        status = android_atomic_release_cas((int32_t) prev, (int32_t)n, (volatile int32_t*) ptr);
-    } while (CC_UNLIKELY(status != 0));
-    return prev;
-}
-
-static int32_t SC_AtomicMin(volatile int32_t *ptr, int32_t value) {
-    int32_t prev, status;
-    do {
-        prev = *ptr;
-        int32_t n = rsMin(value, prev);
-        status = android_atomic_release_cas(prev, n, ptr);
-    } while (CC_UNLIKELY(status != 0));
-    return prev;
-}
-
-static uint32_t SC_AtomicUMax(volatile uint32_t *ptr, uint32_t value) {
-    uint32_t prev, status;
-    do {
-        prev = *ptr;
-        uint32_t n = rsMax(value, prev);
-        status = android_atomic_release_cas((int32_t) prev, (int32_t) n, (volatile int32_t*) ptr);
-    } while (CC_UNLIKELY(status != 0));
-    return prev;
-}
-
-static int32_t SC_AtomicMax(volatile int32_t *ptr, int32_t value) {
-    int32_t prev, status;
-    do {
-        prev = *ptr;
-        int32_t n = rsMax(value, prev);
-        status = android_atomic_release_cas(prev, n, ptr);
-    } while (CC_UNLIKELY(status != 0));
-    return prev;
-}
-
-
-
 //////////////////////////////////////////////////////////////////////////////
 // Class implementation
 //////////////////////////////////////////////////////////////////////////////
@@ -301,34 +185,9 @@ static RsdCpuReference::CpuSymbol gSyms[] = {
     { "_Z17rsMatrixTransposeP12rs_matrix2x2", (void *)&SC_MatrixTranspose_2x2, true },
 
     // RS Math
-    { "_Z6rsRandi", (void *)&SC_randi, true },
-    { "_Z6rsRandii", (void *)&SC_randi2, true },
-    { "_Z6rsRandf", (void *)&SC_randf, true },
     { "_Z6rsRandff", (void *)&SC_randf2, true },
     { "_Z6rsFracf", (void *)&SC_frac, true },
 
-    // Atomics
-    { "_Z11rsAtomicIncPVi", (void *)&SC_AtomicInc, true },
-    { "_Z11rsAtomicIncPVj", (void *)&SC_AtomicInc, true },
-    { "_Z11rsAtomicDecPVi", (void *)&SC_AtomicDec, true },
-    { "_Z11rsAtomicDecPVj", (void *)&SC_AtomicDec, true },
-    { "_Z11rsAtomicAddPVii", (void *)&SC_AtomicAdd, true },
-    { "_Z11rsAtomicAddPVjj", (void *)&SC_AtomicAdd, true },
-    { "_Z11rsAtomicSubPVii", (void *)&SC_AtomicSub, true },
-    { "_Z11rsAtomicSubPVjj", (void *)&SC_AtomicSub, true },
-    { "_Z11rsAtomicAndPVii", (void *)&SC_AtomicAnd, true },
-    { "_Z11rsAtomicAndPVjj", (void *)&SC_AtomicAnd, true },
-    { "_Z10rsAtomicOrPVii", (void *)&SC_AtomicOr, true },
-    { "_Z10rsAtomicOrPVjj", (void *)&SC_AtomicOr, true },
-    { "_Z11rsAtomicXorPVii", (void *)&SC_AtomicXor, true },
-    { "_Z11rsAtomicXorPVjj", (void *)&SC_AtomicXor, true },
-    { "_Z11rsAtomicMinPVii", (void *)&SC_AtomicMin, true },
-    { "_Z11rsAtomicMinPVjj", (void *)&SC_AtomicUMin, true },
-    { "_Z11rsAtomicMaxPVii", (void *)&SC_AtomicMax, true },
-    { "_Z11rsAtomicMaxPVjj", (void *)&SC_AtomicUMax, true },
-    { "_Z11rsAtomicCasPViii", (void *)&SC_AtomicCas, true },
-    { "_Z11rsAtomicCasPVjjj", (void *)&SC_AtomicCas, true },
-
     { NULL, NULL, false }
 };
 
diff --git a/cpu_ref/rsCpuScript.cpp b/cpu_ref/rsCpuScript.cpp
index 356139fb..2ae4d83b 100644
--- a/cpu_ref/rsCpuScript.cpp
+++ b/cpu_ref/rsCpuScript.cpp
@@ -28,29 +28,82 @@
 #include "utils/Timers.h"
 #include "utils/StopWatch.h"
 
-
-#include <bcc/BCCContext.h>
-#include <bcc/Renderscript/RSCompilerDriver.h>
-#include <bcc/Renderscript/RSExecutable.h>
-#include <bcc/Renderscript/RSInfo.h>
+#ifdef RS_COMPATIBILITY_LIB
+    #include <dlfcn.h>
+    #include <stdio.h>
+    #include <string.h>
+#else
+    #include <bcc/BCCContext.h>
+    #include <bcc/Renderscript/RSCompilerDriver.h>
+    #include <bcc/Renderscript/RSExecutable.h>
+    #include <bcc/Renderscript/RSInfo.h>
+#endif
 
 namespace android {
 namespace renderscript {
 
 
+#ifdef RS_COMPATIBILITY_LIB
+#define MAXLINE 500
+#define MAKE_STR_HELPER(S) #S
+#define MAKE_STR(S) MAKE_STR_HELPER(S)
+#define EXPORT_VAR_STR "exportVarCount: "
+#define EXPORT_VAR_STR_LEN strlen(EXPORT_VAR_STR)
+#define EXPORT_FUNC_STR "exportFuncCount: "
+#define EXPORT_FUNC_STR_LEN strlen(EXPORT_FUNC_STR)
+#define EXPORT_FOREACH_STR "exportForEachCount: "
+#define EXPORT_FOREACH_STR_LEN strlen(EXPORT_FOREACH_STR)
+#define OBJECT_SLOT_STR "objectSlotCount: "
+#define OBJECT_SLOT_STR_LEN strlen(OBJECT_SLOT_STR)
+
+// Copy up to a newline or size chars from str -> s, updating str
+// Returns s when successful and NULL when '\0' is finally reached.
+static char* strgets(char *s, int size, const char **ppstr) {
+    if (!ppstr || !*ppstr || **ppstr == '\0' || size < 1) {
+        return NULL;
+    }
+
+    int i;
+    for (i = 0; i < (size - 1); i++) {
+        s[i] = **ppstr;
+        (*ppstr)++;
+        if (s[i] == '\0') {
+            return s;
+        } else if (s[i] == '\n') {
+            s[i+1] = '\0';
+            return s;
+        }
+    }
+
+    // size has been exceeded.
+    s[i] = '\0';
+
+    return s;
+}
+#endif
 
 RsdCpuScriptImpl::RsdCpuScriptImpl(RsdCpuReferenceImpl *ctx, const Script *s) {
     mCtx = ctx;
     mScript = s;
 
+#ifdef RS_COMPATIBILITY_LIB
+    mScriptSO = NULL;
+    mInvokeFunctions = NULL;
+    mForEachFunctions = NULL;
+    mFieldAddress = NULL;
+    mFieldIsObject = NULL;
+    mForEachSignatures = NULL;
+#else
+    mCompilerContext = NULL;
+    mCompilerDriver = NULL;
+    mExecutable = NULL;
+#endif
+
     mRoot = NULL;
     mRootExpand = NULL;
     mInit = NULL;
     mFreeChildren = NULL;
 
-    mCompilerContext = NULL;
-    mCompilerDriver = NULL;
-    mExecutable = NULL;
 
     mBoundAllocs = NULL;
     mIntrinsicData = NULL;
@@ -66,6 +119,7 @@ bool RsdCpuScriptImpl::init(char const *resName, char const *cacheDir,
 
     mCtx->lockMutex();
 
+#ifndef RS_COMPATIBILITY_LIB
     bcc::RSExecutable *exec;
     const bcc::RSInfo *info;
 
@@ -121,11 +175,256 @@ bool RsdCpuScriptImpl::init(char const *resName, char const *cacheDir,
         memset(mBoundAllocs, 0, sizeof(void *) * info->getExportVarNames().size());
     }
 
+#else
+
+    String8 scriptSOName(cacheDir);
+    scriptSOName = scriptSOName.getPathDir();
+    scriptSOName.appendPath("lib");
+    scriptSOName.append("/librs.");
+    scriptSOName.append(resName);
+    scriptSOName.append(".so");
+
+    //script->mHal.drv = drv;
+
+    //ALOGV("Opening up shared object: %s", scriptSOName.string());
+    mScriptSO = dlopen(scriptSOName.string(), RTLD_NOW | RTLD_LOCAL);
+    if (mScriptSO == NULL) {
+        ALOGE("Unable to open shared library (%s): %s",
+              scriptSOName.string(), dlerror());
+
+        // One final attempt to find the library in "/system/lib".
+        // We do this to allow bundled applications to use the compatibility
+        // library fallback path. Those applications don't have a private
+        // library path, so they need to install to the system directly.
+        String8 scriptSONameSystem("/system/lib/librs.");
+        scriptSONameSystem.append(resName);
+        scriptSONameSystem.append(".so");
+        mScriptSO = dlopen(scriptSONameSystem.string(), RTLD_NOW | RTLD_LOCAL);
+        if (mScriptSO == NULL) {
+            ALOGE("Unable to open system shared library (%s): %s",
+                  scriptSONameSystem.string(), dlerror());
+            goto error;
+        }
+    }
+
+    if (mScriptSO) {
+        char line[MAXLINE];
+        mRoot = (RootFunc_t) dlsym(mScriptSO, "root");
+        if (mRoot) {
+            //ALOGE("Found root(): %p", mRoot);
+        }
+        mRootExpand = (RootFunc_t) dlsym(mScriptSO, "root.expand");
+        if (mRootExpand) {
+            //ALOGE("Found root.expand(): %p", mRootExpand);
+        }
+        mInit = (InvokeFunc_t) dlsym(mScriptSO, "init");
+        if (mInit) {
+            //ALOGE("Found init(): %p", mInit);
+        }
+        mFreeChildren = (InvokeFunc_t) dlsym(mScriptSO, ".rs.dtor");
+        if (mFreeChildren) {
+            //ALOGE("Found .rs.dtor(): %p", mFreeChildren);
+        }
+
+        const char *rsInfo = (const char *) dlsym(mScriptSO, ".rs.info");
+        if (rsInfo) {
+            //ALOGE("Found .rs.info(): %p - %s", rsInfo, rsInfo);
+        }
+
+        size_t varCount = 0;
+        if (strgets(line, MAXLINE, &rsInfo) == NULL) {
+            goto error;
+        }
+        if (sscanf(line, EXPORT_VAR_STR "%zu", &varCount) != 1) {
+            ALOGE("Invalid export var count!: %s", line);
+            goto error;
+        }
+
+        mExportedVariableCount = varCount;
+        //ALOGE("varCount: %zu", varCount);
+        if (varCount > 0) {
+            // Start by creating/zeroing this member, since we don't want to
+            // accidentally clean up invalid pointers later (if we error out).
+            mFieldIsObject = new bool[varCount];
+            if (mFieldIsObject == NULL) {
+                goto error;
+            }
+            memset(mFieldIsObject, 0, varCount * sizeof(*mFieldIsObject));
+            mFieldAddress = new void*[varCount];
+            if (mFieldAddress == NULL) {
+                goto error;
+            }
+            for (size_t i = 0; i < varCount; ++i) {
+                if (strgets(line, MAXLINE, &rsInfo) == NULL) {
+                    goto error;
+                }
+                char *c = strrchr(line, '\n');
+                if (c) {
+                    *c = '\0';
+                }
+                mFieldAddress[i] = dlsym(mScriptSO, line);
+                if (mFieldAddress[i] == NULL) {
+                    ALOGE("Failed to find variable address for %s: %s",
+                          line, dlerror());
+                    // Not a critical error if we don't find a global variable.
+                }
+                else {
+                    //ALOGE("Found variable %s at %p", line,
+                    //mFieldAddress[i]);
+                }
+            }
+        }
+
+        size_t funcCount = 0;
+        if (strgets(line, MAXLINE, &rsInfo) == NULL) {
+            goto error;
+        }
+        if (sscanf(line, EXPORT_FUNC_STR "%zu", &funcCount) != 1) {
+            ALOGE("Invalid export func count!: %s", line);
+            goto error;
+        }
+
+        mExportedFunctionCount = funcCount;
+        //ALOGE("funcCount: %zu", funcCount);
+
+        if (funcCount > 0) {
+            mInvokeFunctions = new InvokeFunc_t[funcCount];
+            if (mInvokeFunctions == NULL) {
+                goto error;
+            }
+            for (size_t i = 0; i < funcCount; ++i) {
+                if (strgets(line, MAXLINE, &rsInfo) == NULL) {
+                    goto error;
+                }
+                char *c = strrchr(line, '\n');
+                if (c) {
+                    *c = '\0';
+                }
+
+                mInvokeFunctions[i] = (InvokeFunc_t) dlsym(mScriptSO, line);
+                if (mInvokeFunctions[i] == NULL) {
+                    ALOGE("Failed to get function address for %s(): %s",
+                          line, dlerror());
+                    goto error;
+                }
+                else {
+                    //ALOGE("Found InvokeFunc_t %s at %p", line, mInvokeFunctions[i]);
+                }
+            }
+        }
+
+        size_t forEachCount = 0;
+        if (strgets(line, MAXLINE, &rsInfo) == NULL) {
+            goto error;
+        }
+        if (sscanf(line, EXPORT_FOREACH_STR "%zu", &forEachCount) != 1) {
+            ALOGE("Invalid export forEach count!: %s", line);
+            goto error;
+        }
+
+        if (forEachCount > 0) {
+
+            mForEachSignatures = new uint32_t[forEachCount];
+            if (mForEachSignatures == NULL) {
+                goto error;
+            }
+            mForEachFunctions = new ForEachFunc_t[forEachCount];
+            if (mForEachFunctions == NULL) {
+                goto error;
+            }
+            for (size_t i = 0; i < forEachCount; ++i) {
+                unsigned int tmpSig = 0;
+                char tmpName[MAXLINE];
+
+                if (strgets(line, MAXLINE, &rsInfo) == NULL) {
+                    goto error;
+                }
+                if (sscanf(line, "%u - %" MAKE_STR(MAXLINE) "s",
+                           &tmpSig, tmpName) != 2) {
+                    ALOGE("Invalid export forEach!: %s", line);
+                    goto error;
+                }
+
+                // Lookup the expanded ForEach kernel.
+                strncat(tmpName, ".expand", MAXLINE-1-strlen(tmpName));
+                mForEachSignatures[i] = tmpSig;
+                mForEachFunctions[i] =
+                        (ForEachFunc_t) dlsym(mScriptSO, tmpName);
+                if (mForEachFunctions[i] == NULL) {
+                    ALOGE("Failed to find forEach function address for %s: %s",
+                          tmpName, dlerror());
+                    // Ignore missing root.expand functions.
+                    // root() is always specified at location 0.
+                    if (i != 0) {
+                        goto error;
+                    }
+                }
+                else {
+                    //ALOGE("Found forEach %s at %p", tmpName, mForEachFunctions[i]);
+                }
+            }
+        }
+
+        size_t objectSlotCount = 0;
+        if (strgets(line, MAXLINE, &rsInfo) == NULL) {
+            goto error;
+        }
+        if (sscanf(line, OBJECT_SLOT_STR "%zu", &objectSlotCount) != 1) {
+            ALOGE("Invalid object slot count!: %s", line);
+            goto error;
+        }
+
+        if (objectSlotCount > 0) {
+            rsAssert(varCount > 0);
+            for (size_t i = 0; i < objectSlotCount; ++i) {
+                uint32_t varNum = 0;
+                if (strgets(line, MAXLINE, &rsInfo) == NULL) {
+                    goto error;
+                }
+                if (sscanf(line, "%u", &varNum) != 1) {
+                    ALOGE("Invalid object slot!: %s", line);
+                    goto error;
+                }
+
+                if (varNum < varCount) {
+                    mFieldIsObject[varNum] = true;
+                }
+            }
+        }
+
+        if (varCount > 0) {
+            mBoundAllocs = new Allocation *[varCount];
+            memset(mBoundAllocs, 0, varCount * sizeof(*mBoundAllocs));
+        }
+
+        if (mScriptSO == (void*)1) {
+            //rsdLookupRuntimeStub(script, "acos");
+        }
+    }
+#endif
+
     mCtx->unlockMutex();
     return true;
+
+#ifdef RS_COMPATIBILITY_LIB
+error:
+
+    mCtx->unlockMutex();
+    delete[] mInvokeFunctions;
+    delete[] mForEachFunctions;
+    delete[] mFieldAddress;
+    delete[] mFieldIsObject;
+    delete[] mForEachSignatures;
+    delete[] mBoundAllocs;
+    if (mScriptSO) {
+        dlclose(mScriptSO);
+    }
+    return false;
+#endif
 }
 
 void RsdCpuScriptImpl::populateScript(Script *script) {
+#ifndef RS_COMPATIBILITY_LIB
     const bcc::RSInfo *info = &mExecutable->getInfo();
 
     // Copy info over to runtime
@@ -142,6 +441,21 @@ void RsdCpuScriptImpl::populateScript(Script *script) {
     } else {
         script->mHal.info.root = mRoot;
     }
+#else
+    // Copy info over to runtime
+    script->mHal.info.exportedFunctionCount = mExportedFunctionCount;
+    script->mHal.info.exportedVariableCount = mExportedVariableCount;
+    script->mHal.info.exportedPragmaCount = 0;
+    script->mHal.info.exportedPragmaKeyList = 0;
+    script->mHal.info.exportedPragmaValueList = 0;
+
+    // Bug, need to stash in metadata
+    if (mRootExpand) {
+        script->mHal.info.root = mRootExpand;
+    } else {
+        script->mHal.info.root = mRoot;
+    }
+#endif
 }
 
 
@@ -264,15 +578,19 @@ void RsdCpuScriptImpl::invokeForEach(uint32_t slot,
 }
 
 void RsdCpuScriptImpl::forEachKernelSetup(uint32_t slot, MTLaunchStruct *mtls) {
-
     mtls->script = this;
     mtls->fep.slot = slot;
-
+#ifndef RS_COMPATIBILITY_LIB
     rsAssert(slot < mExecutable->getExportForeachFuncAddrs().size());
     mtls->kernel = reinterpret_cast<ForEachFunc_t>(
                       mExecutable->getExportForeachFuncAddrs()[slot]);
     rsAssert(mtls->kernel != NULL);
     mtls->sig = mExecutable->getInfo().getExportForeachFuncs()[slot].second;
+#else
+    mtls->kernel = reinterpret_cast<ForEachFunc_t>(mForEachFunctions[slot]);
+    rsAssert(mtls->kernel != NULL);
+    mtls->sig = mForEachSignatures[slot];
+#endif
 }
 
 int RsdCpuScriptImpl::invokeRoot() {
@@ -300,7 +618,11 @@ void RsdCpuScriptImpl::invokeFunction(uint32_t slot, const void *params,
 
     RsdCpuScriptImpl * oldTLS = mCtx->setTLS(this);
     reinterpret_cast<void (*)(const void *, uint32_t)>(
+#ifndef RS_COMPATIBILITY_LIB
         mExecutable->getExportFuncAddrs()[slot])(params, paramLength);
+#else
+        mInvokeFunctions[slot])(params, paramLength);
+#endif
     mCtx->setTLS(oldTLS);
 }
 
@@ -313,8 +635,12 @@ void RsdCpuScriptImpl::setGlobalVar(uint32_t slot, const void *data, size_t data
         //return;
     //}
 
+#ifndef RS_COMPATIBILITY_LIB
     int32_t *destPtr = reinterpret_cast<int32_t *>(
                           mExecutable->getExportVarAddrs()[slot]);
+#else
+    int32_t *destPtr = reinterpret_cast<int32_t *>(mFieldAddress[slot]);
+#endif
     if (!destPtr) {
         //ALOGV("Calling setVar on slot = %i which is null", slot);
         return;
@@ -327,8 +653,12 @@ void RsdCpuScriptImpl::setGlobalVarWithElemDims(uint32_t slot, const void *data,
                                                 const Element *elem,
                                                 const size_t *dims, size_t dimLength) {
 
+#ifndef RS_COMPATIBILITY_LIB
     int32_t *destPtr = reinterpret_cast<int32_t *>(
         mExecutable->getExportVarAddrs()[slot]);
+#else
+    int32_t *destPtr = reinterpret_cast<int32_t *>(mFieldAddress[slot]);
+#endif
     if (!destPtr) {
         //ALOGV("Calling setVar on slot = %i which is null", slot);
         return;
@@ -365,8 +695,12 @@ void RsdCpuScriptImpl::setGlobalBind(uint32_t slot, Allocation *data) {
     //rsAssert(!script->mFieldIsObject[slot]);
     //ALOGE("setGlobalBind %p %p %i %p", dc, script, slot, data);
 
+#ifndef RS_COMPATIBILITY_LIB
     int32_t *destPtr = reinterpret_cast<int32_t *>(
                           mExecutable->getExportVarAddrs()[slot]);
+#else
+    int32_t *destPtr = reinterpret_cast<int32_t *>(mFieldAddress[slot]);
+#endif
     if (!destPtr) {
         //ALOGV("Calling setVar on slot = %i which is null", slot);
         return;
@@ -390,8 +724,12 @@ void RsdCpuScriptImpl::setGlobalObj(uint32_t slot, ObjectBase *data) {
         //return;
     //}
 
+#ifndef RS_COMPATIBILITY_LIB
     int32_t *destPtr = reinterpret_cast<int32_t *>(
                           mExecutable->getExportVarAddrs()[slot]);
+#else
+    int32_t *destPtr = reinterpret_cast<int32_t *>(mFieldAddress[slot]);
+#endif
     if (!destPtr) {
         //ALOGV("Calling setVar on slot = %i which is null", slot);
         return;
@@ -401,7 +739,7 @@ void RsdCpuScriptImpl::setGlobalObj(uint32_t slot, ObjectBase *data) {
 }
 
 RsdCpuScriptImpl::~RsdCpuScriptImpl() {
-
+#ifndef RS_COMPATIBILITY_LIB
     if (mExecutable) {
         Vector<void *>::const_iterator var_addr_iter =
             mExecutable->getExportVarAddrs().begin();
@@ -441,6 +779,29 @@ RsdCpuScriptImpl::~RsdCpuScriptImpl() {
     if (mBoundAllocs) {
         delete[] mBoundAllocs;
     }
+#else
+    if (mFieldIsObject) {
+        for (size_t i = 0; i < mExportedVariableCount; ++i) {
+            if (mFieldIsObject[i]) {
+                if (mFieldAddress[i] != NULL) {
+                    ObjectBase **obj_addr =
+                        reinterpret_cast<ObjectBase **>(mFieldAddress[i]);
+                    rsrClearObject(mCtx->getContext(), obj_addr);
+                }
+            }
+        }
+    }
+
+    if (mInvokeFunctions) delete[] mInvokeFunctions;
+    if (mForEachFunctions) delete[] mForEachFunctions;
+    if (mFieldAddress) delete[] mFieldAddress;
+    if (mFieldIsObject) delete[] mFieldIsObject;
+    if (mForEachSignatures) delete[] mForEachSignatures;
+    if (mBoundAllocs) delete[] mBoundAllocs;
+    if (mScriptSO) {
+        dlclose(mScriptSO);
+    }
+#endif
 }
 
 Allocation * RsdCpuScriptImpl::getAllocationForPointer(const void *ptr) const {
diff --git a/cpu_ref/rsCpuScript.h b/cpu_ref/rsCpuScript.h
index 6097c836..b9973c90 100644
--- a/cpu_ref/rsCpuScript.h
+++ b/cpu_ref/rsCpuScript.h
@@ -39,6 +39,12 @@ public:
         const RsForEachStubParamStruct *,
         uint32_t x1, uint32_t x2,
         uint32_t instep, uint32_t outstep);
+#ifdef RS_COMPATIBILITY_LIB
+    typedef void (* InvokeFunc_t)(void);
+    typedef void (* ForEachFunc_t)(void);
+    typedef int (* RootFunc_t)(void);
+    typedef void (*WorkerCallback_t)(void *usr, uint32_t idx);
+#endif
 
     bool init(char const *resName, char const *cacheDir,
               uint8_t const *bitcode, size_t bitcodeSize, uint32_t flags);
@@ -86,6 +92,7 @@ protected:
     RsdCpuReferenceImpl *mCtx;
     const Script *mScript;
 
+#ifndef RS_COMPATIBILITY_LIB
     int (*mRoot)();
     int (*mRootExpand)();
     void (*mInit)();
@@ -94,6 +101,25 @@ protected:
     bcc::BCCContext *mCompilerContext;
     bcc::RSCompilerDriver *mCompilerDriver;
     bcc::RSExecutable *mExecutable;
+#else
+    void *mScriptSO;
+    RootFunc_t mRoot;
+    RootFunc_t mRootExpand;
+    InvokeFunc_t mInit;
+    InvokeFunc_t mFreeChildren;
+    InvokeFunc_t *mInvokeFunctions;
+    ForEachFunc_t *mForEachFunctions;
+
+    void **mFieldAddress;
+    bool *mFieldIsObject;
+    uint32_t *mForEachSignatures;
+
+    // for populate script
+    //int mVersionMajor;
+    //int mVersionMinor;
+    size_t mExportedVariableCount;
+    size_t mExportedFunctionCount;
+#endif
 
     Allocation **mBoundAllocs;
     void * mIntrinsicData;
diff --git a/cpu_ref/rsd_cpu.h b/cpu_ref/rsd_cpu.h
index 1eee7deb..13a96569 100644
--- a/cpu_ref/rsd_cpu.h
+++ b/cpu_ref/rsd_cpu.h
@@ -19,6 +19,7 @@
 
 #include "rsAllocation.h"
 
+#ifndef RS_COMPATIBILITY_LIB
 namespace llvm {
 
 class Module;
@@ -31,6 +32,7 @@ class RSScript;
 typedef llvm::Module* (*RSLinkRuntimeCallback) (bcc::RSScript *, llvm::Module *, llvm::Module *);
 
 }  // end namespace bcc;
+#endif
 
 namespace android {
 namespace renderscript {
diff --git a/driver/rsdCore.cpp b/driver/rsdCore.cpp
index 7b41a47f..367a50bb 100644
--- a/driver/rsdCore.cpp
+++ b/driver/rsdCore.cpp
@@ -19,16 +19,18 @@
 #include "rsdCore.h"
 #include "rsdAllocation.h"
 #include "rsdBcc.h"
-#include "rsdGL.h"
-#include "rsdPath.h"
-#include "rsdProgramStore.h"
-#include "rsdProgramRaster.h"
-#include "rsdProgramVertex.h"
-#include "rsdProgramFragment.h"
-#include "rsdMesh.h"
+#ifndef RS_COMPATIBILITY_LIB
+    #include "rsdGL.h"
+    #include "rsdPath.h"
+    #include "rsdProgramStore.h"
+    #include "rsdProgramRaster.h"
+    #include "rsdProgramVertex.h"
+    #include "rsdProgramFragment.h"
+    #include "rsdMesh.h"
+    #include "rsdFrameBuffer.h"
+#endif
 #include "rsdSampler.h"
 #include "rsdScriptGroup.h"
-#include "rsdFrameBuffer.h"
 
 #include <malloc.h>
 #include "rsContext.h"
@@ -46,11 +48,18 @@ using namespace android::renderscript;
 static void Shutdown(Context *rsc);
 static void SetPriority(const Context *rsc, int32_t priority);
 
+#ifndef RS_COMPATIBILITY_LIB
+    #define NATIVE_FUNC(a) a
+#else
+    #define NATIVE_FUNC(a) NULL
+#endif
+
+
 static RsdHalFunctions FunctionTable = {
-    rsdGLInit,
-    rsdGLShutdown,
-    rsdGLSetSurface,
-    rsdGLSwap,
+    NATIVE_FUNC(rsdGLInit),
+    NATIVE_FUNC(rsdGLShutdown),
+    NATIVE_FUNC(rsdGLSetSurface),
+    NATIVE_FUNC(rsdGLSwap),
 
     Shutdown,
     NULL,
@@ -78,10 +87,10 @@ static RsdHalFunctions FunctionTable = {
         rsdAllocationResize,
         rsdAllocationSyncAll,
         rsdAllocationMarkDirty,
-        rsdAllocationGetSurface,
-        rsdAllocationSetSurface,
-        rsdAllocationIoSend,
-        rsdAllocationIoReceive,
+        NATIVE_FUNC(rsdAllocationGetSurface),
+        NATIVE_FUNC(rsdAllocationSetSurface),
+        NATIVE_FUNC(rsdAllocationIoSend),
+        NATIVE_FUNC(rsdAllocationIoReceive),
         rsdAllocationData1D,
         rsdAllocationData2D,
         rsdAllocationData3D,
@@ -100,40 +109,40 @@ static RsdHalFunctions FunctionTable = {
 
 
     {
-        rsdProgramStoreInit,
-        rsdProgramStoreSetActive,
-        rsdProgramStoreDestroy
+        NATIVE_FUNC(rsdProgramStoreInit),
+        NATIVE_FUNC(rsdProgramStoreSetActive),
+        NATIVE_FUNC(rsdProgramStoreDestroy)
     },
 
     {
-        rsdProgramRasterInit,
-        rsdProgramRasterSetActive,
-        rsdProgramRasterDestroy
+        NATIVE_FUNC(rsdProgramRasterInit),
+        NATIVE_FUNC(rsdProgramRasterSetActive),
+        NATIVE_FUNC(rsdProgramRasterDestroy)
     },
 
     {
-        rsdProgramVertexInit,
-        rsdProgramVertexSetActive,
-        rsdProgramVertexDestroy
+        NATIVE_FUNC(rsdProgramVertexInit),
+        NATIVE_FUNC(rsdProgramVertexSetActive),
+        NATIVE_FUNC(rsdProgramVertexDestroy)
     },
 
     {
-        rsdProgramFragmentInit,
-        rsdProgramFragmentSetActive,
-        rsdProgramFragmentDestroy
+        NATIVE_FUNC(rsdProgramFragmentInit),
+        NATIVE_FUNC(rsdProgramFragmentSetActive),
+        NATIVE_FUNC(rsdProgramFragmentDestroy)
     },
 
     {
-        rsdMeshInit,
-        rsdMeshDraw,
-        rsdMeshDestroy
+        NATIVE_FUNC(rsdMeshInit),
+        NATIVE_FUNC(rsdMeshDraw),
+        NATIVE_FUNC(rsdMeshDestroy)
     },
 
     {
-        rsdPathInitStatic,
-        rsdPathInitDynamic,
-        rsdPathDraw,
-        rsdPathDestroy
+        NATIVE_FUNC(rsdPathInitStatic),
+        NATIVE_FUNC(rsdPathInitDynamic),
+        NATIVE_FUNC(rsdPathDraw),
+        NATIVE_FUNC(rsdPathDestroy)
     },
 
     {
@@ -142,9 +151,9 @@ static RsdHalFunctions FunctionTable = {
     },
 
     {
-        rsdFrameBufferInit,
-        rsdFrameBufferSetActive,
-        rsdFrameBufferDestroy
+        NATIVE_FUNC(rsdFrameBufferInit),
+        NATIVE_FUNC(rsdFrameBufferSetActive),
+        NATIVE_FUNC(rsdFrameBufferDestroy)
     },
 
     {
@@ -193,9 +202,11 @@ void SetPriority(const Context *rsc, int32_t priority) {
 
     dc->mCpuRef->setPriority(priority);
 
+#ifndef RS_COMPATIBILITY_LIB
     if (dc->mHasGraphics) {
         rsdGLSetPriority(rsc, priority);
     }
+#endif
 }
 
 void Shutdown(Context *rsc) {
diff --git a/driver/rsdRuntimeStubs.cpp b/driver/rsdRuntimeStubs.cpp
index 7f86da61..92af7cef 100644
--- a/driver/rsdRuntimeStubs.cpp
+++ b/driver/rsdRuntimeStubs.cpp
@@ -112,6 +112,7 @@ static void SC_AllocationCopy2DRange(Allocation *dstAlloc,
                              srcXoff, srcYoff, srcMip, srcFace);
 }
 
+#ifndef RS_COMPATIBILITY_LIB
 static void SC_AllocationIoSend(Allocation *alloc) {
     Context *rsc = RsdCpuReference::getTlsContext();
     rsdAllocationIoSend(rsc, alloc);
@@ -392,7 +393,7 @@ static void SC_FontColor(float r, float g, float b, float a) {
     Context *rsc = RsdCpuReference::getTlsContext();
     rsrFontColor(rsc, r, g, b, a);
 }
-
+#endif
 
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/rsContext.cpp b/rsContext.cpp
index c227847d..8d972a2e 100644
--- a/rsContext.cpp
+++ b/rsContext.cpp
@@ -262,6 +262,8 @@ bool Context::loadRuntime(const char* filename, Context* rsc) {
     return true;
 }
 
+extern "C" bool rsdHalInit(RsContext c, uint32_t version_major, uint32_t version_minor);
+
 void * Context::threadProc(void *vrsc) {
     Context *rsc = static_cast<Context *>(vrsc);
 #ifndef ANDROID_RS_SERIALIZE
@@ -290,6 +292,7 @@ void * Context::threadProc(void *vrsc) {
     bool loadDefault = true;
 
     // Provide a mechanism for dropping in a different RS driver.
+#ifndef RS_COMPATIBILITY_LIB
 #ifdef OVERRIDE_RS_DRIVER
 #define XSTR(S) #S
 #define STR(S) XSTR(S)
@@ -319,6 +322,12 @@ void * Context::threadProc(void *vrsc) {
             return NULL;
         }
     }
+#else // RS_COMPATIBILITY_LIB
+    if (rsdHalInit(rsc, 0, 0) != true) {
+        return NULL;
+    }
+#endif
+
 
     rsc->mHal.funcs.setPriority(rsc, rsc->mThreadPriority);
 
diff --git a/rsObjectBase.cpp b/rsObjectBase.cpp
index 6a64582b..162f162e 100644
--- a/rsObjectBase.cpp
+++ b/rsObjectBase.cpp
@@ -111,7 +111,7 @@ bool ObjectBase::checkDelete(const ObjectBase *ref) {
 bool ObjectBase::decUserRef() const {
     rsAssert(mUserRefCount > 0);
 #if RS_OBJECT_DEBUG
-    ALOGV("ObjectBase %p decU ref %i, %i", this, mUserRefCount, mSysRefCount);
+    //ALOGV("ObjectBase %p decU ref %i, %i", this, mUserRefCount, mSysRefCount);
     if (mUserRefCount <= 0) {
         mStack.dump();
     }
diff --git a/rsScriptC_Lib.cpp b/rsScriptC_Lib.cpp
index e8c9d1d4..a8591f50 100644
--- a/rsScriptC_Lib.cpp
+++ b/rsScriptC_Lib.cpp
@@ -92,7 +92,12 @@ tm* rsrLocalTime(Context *rsc, tm *local, time_t *timer) {
     // have to apply locking for proper behavior in RenderScript.
     pthread_mutex_lock(&rsc->gLibMutex);
     tm *tmp = localtime(timer);
+#ifndef RS_COMPATIBILITY_LIB
     memcpy(local, tmp, sizeof(*tmp));
+#else
+    // WORKAROUND to struct rs_tm != struct tm
+    memcpy(local, tmp, sizeof(int)*9);
+#endif
     pthread_mutex_unlock(&rsc->gLibMutex);
     return local;
 }