1/*
2 * Copyright (C) 2015 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
17#ifndef ANDROID_RENDERSCRIPT_EXECUTABLE_H
18#define ANDROID_RENDERSCRIPT_EXECUTABLE_H
19
20
21#include "rsCpuScript.h"
22
23#include <stdlib.h>
24#include <string>
25
26namespace android {
27namespace renderscript {
28
29class Context;
30
31class SharedLibraryUtils {
32public:
33#ifndef RS_COMPATIBILITY_LIB
34    // Creates a shared library in cacheDir for the bitcode named resName.
35    // If reuse is false and SOPath is not nullptr, saves the filename
36    // used for the shared library in SOPath.
37    static bool createSharedLibrary(const char* driverName,
38                                    const char* cacheDir,
39                                    const char* resName,
40                                    const bool reuse = true,
41                                    std::string *SOPath = nullptr);
42#endif
43
44    // Load the shared library referred to by cacheDir and resName. If we have
45    // already loaded this library, we instead create a new copy (in the
46    // cache dir) and then load that. We then immediately destroy the copy.
47    // This is required behavior to implement script instancing for the support
48    // library, since shared objects are loaded and de-duped by name only.
49
50    // For 64bit RS Support Lib, the shared lib path cannot be constructed from
51    // cacheDir, so nativeLibDir is needed to load shared libs.
52    static void* loadSharedLibrary(const char *cacheDir, const char *resName,
53                                   const char *nativeLibDir = nullptr,
54                                   bool *alreadyLoaded = nullptr);
55
56    // Load the shared library referred to by fullPath, and delete it right
57    // after loading it. Files loaded by this function are only used once, e.g.,
58    // shared libraries generated for scripts in a debug context. Deleting them
59    // is OK in this case since the shared libraries have already been dlopened.
60    // Deletion is also required because such files are not intended for reuse.
61    static void* loadAndDeleteSharedLibrary(const char *fullPath);
62
63    // Create a len length string containing random characters from [A-Za-z0-9].
64    static std::string getRandomString(size_t len);
65
66private:
67    // Attempt to load the shared library from origName, but then fall back to
68    // creating a copy of the shared library if necessary (to ensure instancing).
69    // This function returns the dlopen()-ed handle if successful.
70    static void *loadSOHelper(const char *origName, const char *cacheDir,
71                              const char *resName, bool* alreadyLoaded = nullptr);
72
73    static const char* LD_EXE_PATH;
74    static const char* RS_CACHE_DIR;
75};
76
77class ScriptExecutable {
78public:
79    ScriptExecutable(void** fieldAddress, bool* fieldIsObject,
80                     const char* const * fieldName, size_t varCount,
81                     InvokeFunc_t* invokeFunctions, size_t funcCount,
82                     ForEachFunc_t* forEachFunctions, uint32_t* forEachSignatures,
83                     size_t forEachCount,
84                     ReduceDescription *reduceDescriptions, size_t reduceCount,
85                     const char** pragmaKeys, const char** pragmaValues,
86                     size_t pragmaCount,
87                     const char **globalNames, const void **globalAddresses,
88                     const size_t *globalSizes,
89                     const uint32_t *globalProperties, size_t globalEntries,
90                     bool isThreadable, uint32_t buildChecksum) :
91        mFieldAddress(fieldAddress), mFieldIsObject(fieldIsObject),
92        mFieldName(fieldName), mExportedVarCount(varCount),
93        mInvokeFunctions(invokeFunctions), mFuncCount(funcCount),
94        mForEachFunctions(forEachFunctions), mForEachSignatures(forEachSignatures),
95        mForEachCount(forEachCount),
96        mReduceDescriptions(reduceDescriptions), mReduceCount(reduceCount),
97        mPragmaKeys(pragmaKeys), mPragmaValues(pragmaValues),
98        mPragmaCount(pragmaCount), mGlobalNames(globalNames),
99        mGlobalAddresses(globalAddresses), mGlobalSizes(globalSizes),
100        mGlobalProperties(globalProperties), mGlobalEntries(globalEntries),
101        mIsThreadable(isThreadable), mBuildChecksum(buildChecksum) {
102    }
103
104    ~ScriptExecutable() {
105        for (size_t i = 0; i < mExportedVarCount; ++i) {
106            if (mFieldIsObject[i]) {
107                if (mFieldAddress[i] != nullptr) {
108                    rs_object_base *obj_addr =
109                            reinterpret_cast<rs_object_base *>(mFieldAddress[i]);
110                    rsrClearObject(obj_addr);
111                }
112            }
113        }
114
115        for (size_t i = 0; i < mPragmaCount; ++i) {
116            delete [] mPragmaKeys[i];
117            delete [] mPragmaValues[i];
118        }
119        delete[] mPragmaValues;
120        delete[] mPragmaKeys;
121
122        delete[] mReduceDescriptions;
123
124        delete[] mForEachSignatures;
125        delete[] mForEachFunctions;
126
127        delete[] mInvokeFunctions;
128
129        for (size_t i = 0; i < mExportedVarCount; i++) {
130            delete[] mFieldName[i];
131        }
132        delete[] mFieldName;
133        delete[] mFieldIsObject;
134        delete[] mFieldAddress;
135    }
136
137    // Create an ScriptExecutable object from a shared object.
138    // If expectedChecksum is not zero, it will be compared to the checksum
139    // embedded in the shared object. A mismatch will cause a failure.
140    // If succeeded, returns the new object. Otherwise, returns nullptr.
141    static ScriptExecutable*
142            createFromSharedObject(void* sharedObj,
143                                   uint32_t expectedChecksum = 0);
144
145    size_t getExportedVariableCount() const { return mExportedVarCount; }
146    size_t getExportedFunctionCount() const { return mFuncCount; }
147    size_t getExportedForEachCount() const { return mForEachCount; }
148    size_t getExportedReduceCount() const { return mReduceCount; }
149    size_t getPragmaCount() const { return mPragmaCount; }
150
151    void* getFieldAddress(int slot) const { return mFieldAddress[slot]; }
152    void* getFieldAddress(const char* name) const;
153    bool getFieldIsObject(int slot) const { return mFieldIsObject[slot]; }
154    const char* getFieldName(int slot) const { return mFieldName[slot]; }
155
156    InvokeFunc_t getInvokeFunction(int slot) const { return mInvokeFunctions[slot]; }
157
158    ForEachFunc_t getForEachFunction(int slot) const { return mForEachFunctions[slot]; }
159    uint32_t getForEachSignature(int slot) const { return mForEachSignatures[slot]; }
160
161    const ReduceDescription* getReduceDescription(int slot) const {
162        return &mReduceDescriptions[slot];
163    }
164
165    const char ** getPragmaKeys() const { return mPragmaKeys; }
166    const char ** getPragmaValues() const { return mPragmaValues; }
167
168    const char* getGlobalName(int i) const {
169        if (i < mGlobalEntries) {
170            return mGlobalNames[i];
171        } else {
172            return nullptr;
173        }
174    }
175    const void* getGlobalAddress(int i) const {
176        if (i < mGlobalEntries) {
177            return mGlobalAddresses[i];
178        } else {
179            return nullptr;
180        }
181    }
182    size_t getGlobalSize(int i) const {
183        if (i < mGlobalEntries) {
184            return mGlobalSizes[i];
185        } else {
186            return 0;
187        }
188    }
189    uint32_t getGlobalProperties(int i) const {
190        if (i < mGlobalEntries) {
191            return mGlobalProperties[i];
192        } else {
193            return 0;
194        }
195    }
196    int getGlobalEntries() const { return mGlobalEntries; }
197
198    bool getThreadable() const { return mIsThreadable; }
199
200    uint32_t getBuildChecksum() const { return mBuildChecksum; }
201
202    bool dumpGlobalInfo() const;
203
204private:
205    void** mFieldAddress;
206    bool* mFieldIsObject;
207    const char* const * mFieldName;
208    size_t mExportedVarCount;
209
210    InvokeFunc_t* mInvokeFunctions;
211    size_t mFuncCount;
212
213    ForEachFunc_t* mForEachFunctions;
214    uint32_t* mForEachSignatures;
215    size_t mForEachCount;
216
217    ReduceDescription* mReduceDescriptions;
218    size_t mReduceCount;
219
220    const char ** mPragmaKeys;
221    const char ** mPragmaValues;
222    size_t mPragmaCount;
223
224    const char ** mGlobalNames;
225    const void ** mGlobalAddresses;
226    const size_t * mGlobalSizes;
227    const uint32_t * mGlobalProperties;
228    int mGlobalEntries;
229
230    bool mIsThreadable;
231    uint32_t mBuildChecksum;
232};
233
234}  // namespace renderscript
235}  // namespace android
236
237#endif  // ANDROID_RENDERSCRIPT_EXECUTABLE_H
238