Remove STL references from header files
b/19148482
Change-Id: I2138664d8ef51d15da23be69ac7d224f30224f42
diff --git a/cpu_ref/rsCpuScript.cpp b/cpu_ref/rsCpuScript.cpp
index 3190d79..f975094 100644
--- a/cpu_ref/rsCpuScript.cpp
+++ b/cpu_ref/rsCpuScript.cpp
@@ -533,6 +533,14 @@
size_t pragmaCount = 0;
bool isThreadable = true;
+ void** fieldAddress = nullptr;
+ bool* fieldIsObject = nullptr;
+ InvokeFunc_t* invokeFunctions = nullptr;
+ ForEachFunc_t* forEachFunctions = nullptr;
+ uint32_t* forEachSignatures = nullptr;
+ const char ** pragmaKeys = nullptr;
+ const char ** pragmaValues = nullptr;
+
const char *rsInfo = (const char *) dlsym(sharedObj, ".rs.info");
if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
@@ -543,11 +551,19 @@
return nullptr;
}
- std::vector<void*> fieldAddress;
+ fieldAddress = new void*[varCount];
+ if (fieldAddress == nullptr) {
+ return nullptr;
+ }
+
+ fieldIsObject = new bool[varCount];
+ if (fieldIsObject == nullptr) {
+ goto error;
+ }
for (size_t i = 0; i < varCount; ++i) {
if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
- return nullptr;
+ goto error;
}
char *c = strrchr(line, '\n');
if (c) {
@@ -559,22 +575,26 @@
line, dlerror());
// Not a critical error if we don't find a global variable.
}
- fieldAddress.push_back(addr);
+ fieldAddress[i] = addr;
+ fieldIsObject[i] = false;
}
if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
- return nullptr;
+ goto error;
}
if (sscanf(line, EXPORT_FUNC_STR "%zu", &funcCount) != 1) {
ALOGE("Invalid export func count!: %s", line);
- return nullptr;
+ goto error;
}
- std::vector<InvokeFunc_t> invokeFunctions(funcCount);
+ invokeFunctions = new InvokeFunc_t[funcCount];
+ if (invokeFunctions == nullptr) {
+ goto error;
+ }
for (size_t i = 0; i < funcCount; ++i) {
if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
- return nullptr ;
+ goto error;
}
char *c = strrchr(line, '\n');
if (c) {
@@ -585,32 +605,39 @@
if (invokeFunctions[i] == nullptr) {
ALOGE("Failed to get function address for %s(): %s",
line, dlerror());
- return nullptr;
+ goto error;
}
}
if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
- return nullptr;
+ goto error;
}
if (sscanf(line, EXPORT_FOREACH_STR "%zu", &forEachCount) != 1) {
ALOGE("Invalid export forEach count!: %s", line);
- return nullptr;
+ goto error;
}
- std::vector<ForEachFunc_t> forEachFunctions(forEachCount);
- std::vector<uint32_t> forEachSignatures(forEachCount);
+ forEachFunctions = new ForEachFunc_t[forEachCount];
+ if (forEachFunctions == nullptr) {
+ goto error;
+ }
+
+ forEachSignatures = new uint32_t[forEachCount];
+ if (forEachSignatures == nullptr) {
+ goto error;
+ }
for (size_t i = 0; i < forEachCount; ++i) {
unsigned int tmpSig = 0;
char tmpName[MAXLINE];
if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
- return nullptr;
+ goto error;
}
if (sscanf(line, "%u - %" MAKE_STR(MAXLINE) "s",
&tmpSig, tmpName) != 2) {
ALOGE("Invalid export forEach!: %s", line);
- return nullptr;
+ goto error;
}
// Lookup the expanded ForEach kernel.
@@ -623,29 +650,26 @@
// root() is always specified at location 0.
ALOGE("Failed to find forEach function address for %s: %s",
tmpName, dlerror());
- return nullptr;
+ goto error;
}
}
if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
- return nullptr;
+ goto error;
}
if (sscanf(line, OBJECT_SLOT_STR "%zu", &objectSlotCount) != 1) {
ALOGE("Invalid object slot count!: %s", line);
- return nullptr;
+ goto error;
}
- std::vector<bool> fieldIsObject(varCount, false);
-
- rsAssert(varCount > 0);
for (size_t i = 0; i < objectSlotCount; ++i) {
uint32_t varNum = 0;
if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
- return nullptr;
+ goto error;
}
if (sscanf(line, "%u", &varNum) != 1) {
ALOGE("Invalid object slot!: %s", line);
- return nullptr;
+ goto error;
}
if (varNum < varCount) {
@@ -653,31 +677,36 @@
}
}
-#ifdef RS_COMPATIBILITY_LIB
+#ifndef RS_COMPATIBILITY_LIB
// Do not attempt to read pragmas or isThreadable flag in compat lib path.
// Neither is applicable for compat lib
- std::vector<const char *> pragmaKeys(pragmaCount);
- std::vector<const char *> pragmaValues(pragmaCount);
- isThreadable = true;
-
-#else
if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
- return nullptr;
+ goto error;
}
if (sscanf(line, PRAGMA_STR "%zu", &pragmaCount) != 1) {
ALOGE("Invalid pragma count!: %s", line);
- return nullptr;
+ goto error;
}
- std::vector<const char *> pragmaKeys(pragmaCount);
- std::vector<const char *> pragmaValues(pragmaCount);
+ pragmaKeys = new const char*[pragmaCount];
+ if (pragmaKeys == nullptr) {
+ goto error;
+ }
+
+ pragmaValues = new const char*[pragmaCount];
+ if (pragmaValues == nullptr) {
+ goto error;
+ }
+
+ bzero(pragmaKeys, sizeof(char*) * pragmaCount);
+ bzero(pragmaValues, sizeof(char*) * pragmaCount);
for (size_t i = 0; i < pragmaCount; ++i) {
if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
ALOGE("Unable to read pragma at index %zu!", i);
- return nullptr;
+ goto error;
}
char key[MAXLINE];
@@ -691,12 +720,7 @@
{
ALOGE("Invalid pragma value!: %s", line);
- // free previously allocated keys and values
- for (size_t idx = 0; idx < i; ++idx) {
- delete [] pragmaKeys[idx];
- delete [] pragmaValues[idx];
- }
- return nullptr;
+ goto error;
}
char *pKey = new char[strlen(key)+1];
@@ -710,35 +734,62 @@
}
if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
- return nullptr;
+ goto error;
}
char tmpFlag[4];
if (sscanf(line, THREADABLE_STR "%4s", tmpFlag) != 1) {
ALOGE("Invalid threadable flag!: %s", line);
- return nullptr;
+ goto error;
}
- if (strcmp(tmpFlag, "yes") == 0)
+ if (strcmp(tmpFlag, "yes") == 0) {
isThreadable = true;
- else if (strcmp(tmpFlag, "no") == 0)
+ } else if (strcmp(tmpFlag, "no") == 0) {
isThreadable = false;
- else {
+ } else {
ALOGE("Invalid threadable flag!: %s", tmpFlag);
- return nullptr;
+ goto error;
}
-#endif
+#endif // RS_COMPATIBILITY_LIB
return new ScriptExecutable(
- RSContext, fieldAddress, fieldIsObject, invokeFunctions,
- forEachFunctions, forEachSignatures, pragmaKeys, pragmaValues,
+ RSContext, fieldAddress, fieldIsObject, varCount,
+ invokeFunctions, funcCount,
+ forEachFunctions, forEachSignatures, forEachCount,
+ pragmaKeys, pragmaValues, pragmaCount,
isThreadable);
+
+error:
+
+#ifndef RS_COMPATIBILITY_LIB
+ for (size_t idx = 0; idx < pragmaCount; ++idx) {
+ if (pragmaKeys[idx] != nullptr) {
+ delete [] pragmaKeys[idx];
+ }
+ if (pragmaValues[idx] != nullptr) {
+ delete [] pragmaValues[idx];
+ }
+ }
+
+ delete[] pragmaValues;
+ delete[] pragmaKeys;
+#endif // RS_COMPATIBILITY_LIB
+
+ delete[] forEachSignatures;
+ delete[] forEachFunctions;
+ delete[] invokeFunctions;
+ delete[] fieldIsObject;
+ delete[] fieldAddress;
+
+ return nullptr;
}
bool RsdCpuScriptImpl::init(char const *resName, char const *cacheDir,
uint8_t const *bitcode, size_t bitcodeSize,
uint32_t flags, char const *bccPluginName) {
- //ALOGE("rsdScriptCreate %p %p %p %p %i %i %p", rsc, resName, cacheDir, bitcode, bitcodeSize, flags, lookupFunc);
+ //ALOGE("rsdScriptCreate %p %p %p %p %i %i %p", rsc, resName, cacheDir,
+ // bitcode, bitcodeSize, flags, lookupFunc);
//ALOGE("rsdScriptInit %p %p", rsc, script);
mCtx->lockMutex();
@@ -892,10 +943,8 @@
script->mHal.info.exportedFunctionCount = mScriptExec->getExportedFunctionCount();
script->mHal.info.exportedVariableCount = mScriptExec->getExportedVariableCount();
script->mHal.info.exportedPragmaCount = mScriptExec->getPragmaCount();;
- script->mHal.info.exportedPragmaKeyList =
- const_cast<const char**>(&mScriptExec->getPragmaKeys().front());
- script->mHal.info.exportedPragmaValueList =
- const_cast<const char**>(&mScriptExec->getPragmaValues().front());
+ script->mHal.info.exportedPragmaKeyList = mScriptExec->getPragmaKeys();
+ script->mHal.info.exportedPragmaValueList = mScriptExec->getPragmaValues();
// Bug, need to stash in metadata
if (mRootExpand) {
@@ -949,7 +998,8 @@
for (int Index = inLen; --Index >= 1;) {
if (!ain0->hasSameDims(ains[Index])) {
mCtx->getContext()->setError(RS_ERROR_BAD_SCRIPT,
- "Failed to launch kernel; dimensions of input and output allocations do not match.");
+ "Failed to launch kernel; dimensions of input and output"
+ "allocations do not match.");
return false;
}
@@ -1128,7 +1178,8 @@
if ((ap = (void*)memalign(16, paramLength)) != nullptr) {
memcpy(ap, params, paramLength);
} else {
- ALOGE("x86_64: invokeFunction memalign error, still use params which is not 16 bytes aligned.");
+ ALOGE("x86_64: invokeFunction memalign error, still use params which"
+ " is not 16 bytes aligned.");
}
}
#endif
diff --git a/cpu_ref/rsCpuScript.h b/cpu_ref/rsCpuScript.h
index 873a79a..e4ae4d3 100644
--- a/cpu_ref/rsCpuScript.h
+++ b/cpu_ref/rsCpuScript.h
@@ -67,26 +67,25 @@
class ScriptExecutable {
public:
ScriptExecutable(Context* RSContext,
- std::vector<void*>& fieldAddress,
- std::vector<bool>& fieldIsObject,
- std::vector<InvokeFunc_t>& invokeFunctions,
- std::vector<ForEachFunc_t>& forEachFunctions,
- std::vector<uint32_t>& forEachSignatures,
- std::vector<const char *> &pragmaKeys,
- std::vector<const char *> &pragmaValues,
- bool isThreadable)
- : mIsThreadable(isThreadable), mRS(RSContext) {
- mFieldAddress.swap(fieldAddress);
- mFieldIsObject.swap(fieldIsObject);
- mInvokeFunctions.swap(invokeFunctions);
- mForEachFunctions.swap(forEachFunctions);
- mForEachSignatures.swap(forEachSignatures);
- mPragmaKeys.swap(pragmaKeys);
- mPragmaValues.swap(pragmaValues);
+ void** fieldAddress, bool* fieldIsObject, size_t varCount,
+ InvokeFunc_t* invokeFunctions, size_t funcCount,
+ ForEachFunc_t* forEachFunctions, uint32_t* forEachSignatures,
+ size_t forEachCount,
+ const char ** pragmaKeys, const char ** pragmaValues,
+ size_t pragmaCount,
+ bool isThreadable) :
+ mFieldAddress(fieldAddress), mFieldIsObject(fieldIsObject),
+ mExportedVarCount(varCount),
+ mInvokeFunctions(invokeFunctions), mFuncCount(funcCount),
+ mForEachFunctions(forEachFunctions), mForEachSignatures(forEachSignatures),
+ mForEachCount(forEachCount),
+ mPragmaKeys(pragmaKeys), mPragmaValues(pragmaValues),
+ mPragmaCount(pragmaCount),
+ mIsThreadable(isThreadable), mRS(RSContext) {
}
~ScriptExecutable() {
- for (size_t i = 0; i < mFieldAddress.size(); ++i) {
+ for (size_t i = 0; i < mExportedVarCount; ++i) {
if (mFieldIsObject[i]) {
if (mFieldAddress[i] != nullptr) {
rs_object_base *obj_addr =
@@ -96,19 +95,27 @@
}
}
- for (size_t i = 0; i < mPragmaKeys.size(); ++i) {
+ for (size_t i = 0; i < mPragmaCount; ++i) {
delete [] mPragmaKeys[i];
delete [] mPragmaValues[i];
}
+
+ delete[] mPragmaValues;
+ delete[] mPragmaKeys;
+ delete[] mForEachSignatures;
+ delete[] mForEachFunctions;
+ delete[] mInvokeFunctions;
+ delete[] mFieldIsObject;
+ delete[] mFieldAddress;
}
static ScriptExecutable*
createFromSharedObject(Context* RSContext, void* sharedObj);
- size_t getExportedVariableCount() const { return mFieldAddress.size(); }
- size_t getExportedFunctionCount() const { return mInvokeFunctions.size(); }
- size_t getExportedForEachCount() const { return mForEachFunctions.size(); }
- size_t getPragmaCount() const { return mPragmaKeys.size(); }
+ size_t getExportedVariableCount() const { return mExportedVarCount; }
+ size_t getExportedFunctionCount() const { return mFuncCount; }
+ size_t getExportedForEachCount() const { return mForEachCount; }
+ size_t getPragmaCount() const { return mPragmaCount; }
void* getFieldAddress(int slot) const { return mFieldAddress[slot]; }
bool getFieldIsObject(int slot) const { return mFieldIsObject[slot]; }
@@ -116,19 +123,26 @@
ForEachFunc_t getForEachFunction(int slot) const { return mForEachFunctions[slot]; }
uint32_t getForEachSignature(int slot) const { return mForEachSignatures[slot]; }
- const std::vector<const char *> & getPragmaKeys() const { return mPragmaKeys; }
- const std::vector<const char *> & getPragmaValues() const { return mPragmaValues; }
+ const char ** getPragmaKeys() const { return mPragmaKeys; }
+ const char ** getPragmaValues() const { return mPragmaValues; }
bool getThreadable() const { return mIsThreadable; }
private:
- std::vector<void*> mFieldAddress;
- std::vector<bool> mFieldIsObject;
- std::vector<InvokeFunc_t> mInvokeFunctions;
- std::vector<ForEachFunc_t> mForEachFunctions;
- std::vector<uint32_t> mForEachSignatures;
- std::vector<const char *> mPragmaKeys;
- std::vector<const char *> mPragmaValues;
+ void** mFieldAddress;
+ bool* mFieldIsObject;
+ size_t mExportedVarCount;
+
+ InvokeFunc_t* mInvokeFunctions;
+ size_t mFuncCount;
+
+ ForEachFunc_t* mForEachFunctions;
+ uint32_t* mForEachSignatures;
+ size_t mForEachCount;
+
+ const char ** mPragmaKeys;
+ const char ** mPragmaValues;
+ size_t mPragmaCount;
bool mIsThreadable;