RSExecutable.cpp revision c89f78b40e7823eb2d08e7129794c9f6f1992c08 
1/*
2 * Copyright 2012, 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#include "bcc/Renderscript/RSExecutable.h"
18
19#include "bcc/Config/Config.h"
20#include "bcc/Support/Disassembler.h"
21#include "bcc/Support/FileBase.h"
22#include "bcc/Support/Log.h"
23#include "bcc/Support/OutputFile.h"
24#include "bcc/ExecutionEngine/SymbolResolverProxy.h"
25
26#include <utils/String8.h>
27
28using namespace bcc;
29
30const char *RSExecutable::SpecialFunctionNames[] = {
31  "root",      // Graphics drawing function or compute kernel.
32  "init",      // Initialization routine called implicitly on startup.
33  ".rs.dtor",  // Static global destructor for a script instance.
34  ".rs.info",  // Variable containing string of RS metadata info.
35  NULL         // Must be NULL-terminated.
36};
37
38RSExecutable *RSExecutable::Create(RSInfo &pInfo,
39                                   FileBase &pObjFile,
40                                   SymbolResolverProxy &pResolver) {
41  // Load the object file. Enable the GDB's JIT debugging if the script contains
42  // debug information.
43  ObjectLoader *loader = ObjectLoader::Load(pObjFile,
44                                            pResolver,
45                                            pInfo.hasDebugInformation());
46  if (loader == NULL) {
47    return NULL;
48  }
49
50  // Now, all things required to build a RSExecutable object are ready.
51  RSExecutable *result = new (std::nothrow) RSExecutable(pInfo,
52                                                         pObjFile,
53                                                         *loader);
54  if (result == NULL) {
55    ALOGE("Out of memory when create object to hold RS result file for %s!",
56          pObjFile.getName().c_str());
57    return NULL;
58  }
59
60  unsigned idx;
61  // Resolve addresses of RS export vars.
62  idx = 0;
63  const RSInfo::ExportVarNameListTy &export_var_names =
64      pInfo.getExportVarNames();
65  for (RSInfo::ExportVarNameListTy::const_iterator
66           var_iter = export_var_names.begin(),
67           var_end = export_var_names.end(); var_iter != var_end;
68       var_iter++, idx++) {
69    const char *name = *var_iter;
70    void *addr = result->getSymbolAddress(name);
71    if (addr == NULL) {
72        //ALOGW("RS export var at entry #%u named %s cannot be found in the result "
73        //"object!", idx, name);
74    }
75    result->mExportVarAddrs.push_back(addr);
76  }
77
78  // Resolve addresses of RS export functions.
79  idx = 0;
80  const RSInfo::ExportFuncNameListTy &export_func_names =
81      pInfo.getExportFuncNames();
82  for (RSInfo::ExportFuncNameListTy::const_iterator
83           func_iter = export_func_names.begin(),
84           func_end = export_func_names.end(); func_iter != func_end;
85       func_iter++, idx++) {
86    const char *name = *func_iter;
87    void *addr = result->getSymbolAddress(name);
88    if (addr == NULL) {
89        //      ALOGW("RS export func at entry #%u named %s cannot be found in the result"
90        //" object!", idx, name);
91    }
92    result->mExportFuncAddrs.push_back(addr);
93  }
94
95  // Resolve addresses of expanded RS foreach function.
96  idx = 0;
97  const RSInfo::ExportForeachFuncListTy &export_foreach_funcs =
98      pInfo.getExportForeachFuncs();
99  for (RSInfo::ExportForeachFuncListTy::const_iterator
100           foreach_iter = export_foreach_funcs.begin(),
101           foreach_end = export_foreach_funcs.end();
102       foreach_iter != foreach_end; foreach_iter++, idx++) {
103    const char *func_name = foreach_iter->first;
104    android::String8 expanded_func_name(func_name);
105    expanded_func_name.append(".expand");
106    void *addr = result->getSymbolAddress(expanded_func_name.string());
107    if (addr == NULL) {
108        //      ALOGW("Expanded RS foreach at entry #%u named %s cannot be found in the "
109        //            "result object!", idx, expanded_func_name.string());
110    }
111    result->mExportForeachFuncAddrs.push_back(addr);
112  }
113
114  // Copy pragma key/value pairs from RSInfo::getPragmas() into mPragmaKeys and
115  // mPragmaValues, respectively.
116  const RSInfo::PragmaListTy &pragmas = pInfo.getPragmas();
117  for (RSInfo::PragmaListTy::const_iterator pragma_iter = pragmas.begin(),
118          pragma_end = pragmas.end(); pragma_iter != pragma_end;
119       pragma_iter++){
120    result->mPragmaKeys.push_back(pragma_iter->first);
121    result->mPragmaValues.push_back(pragma_iter->second);
122  }
123
124  return result;
125}
126
127bool RSExecutable::syncInfo(bool pForce) {
128  if (!pForce && !mIsInfoDirty) {
129    return true;
130  }
131
132  android::String8 info_path = RSInfo::GetPath(*mObjFile);
133  OutputFile info_file(info_path.string(), FileBase::kTruncate);
134
135  if (info_file.hasError()) {
136    ALOGE("Failed to open the info file %s for write! (%s)", info_path.string(),
137          info_file.getErrorMessage().c_str());
138    return false;
139  }
140
141  // Operation to the RS info file need to acquire the lock on the output file
142  // first.
143  if (!mObjFile->lock(FileBase::kWriteLock)) {
144    ALOGE("Write to RS info file %s required the acquisition of the write lock "
145          "on %s but got failure! (%s)", info_path.string(),
146          mObjFile->getName().c_str(), info_file.getErrorMessage().c_str());
147    return false;
148  }
149
150  // Perform the write.
151  if (!mInfo->write(info_file)) {
152    ALOGE("Failed to sync the RS info file %s!", info_path.string());
153    mObjFile->unlock();
154    return false;
155  }
156
157  mObjFile->unlock();
158  mIsInfoDirty = false;
159  return true;
160}
161
162void RSExecutable::dumpDisassembly(OutputFile &pOutput) const {
163#if DEBUG_MC_DISASSEMBLER
164  if (pOutput.hasError()) {
165    return;
166  }
167
168  // Get MC codegen emitted function name list.
169  android::Vector<const char *> func_list;
170
171  if (!mLoader->getSymbolNameList(func_list, ObjectLoader::kFunctionType)) {
172      ALOGW("Failed to get the list of function name in %s for disassembly!",
173            mObjFile->getName().c_str());
174  } else {
175    // Disassemble each function
176    for (size_t i = 0, e = func_list.size(); i != e; i++) {
177      const char* func_name = func_list[i];
178      void *func = mLoader->getSymbolAddress(func_name);
179      size_t func_size = mLoader->getSymbolSize(func_name);
180
181      if (func == NULL) {
182        continue;
183      }
184      DisassembleResult result =
185          Disassemble(pOutput, DEFAULT_TARGET_TRIPLE_STRING, func_name,
186                      reinterpret_cast<const uint8_t *>(func), func_size);
187
188      if (result != kDisassembleSuccess) {
189          ALOGW("Failed to disassemble the function %s in %s (error code=%zu)!",
190                func_name, mObjFile->getName().c_str(), static_cast<size_t>(result));
191
192        if (result != kDisassembleInvalidInstruction) {
193            ALOGW("And the error occured in disassembler is fatal. Abort "
194                  "disassembler on remaining functions!");
195          break;
196        }
197      }
198    }
199  }
200#endif
201  return;
202}
203
204RSExecutable::~RSExecutable() {
205  syncInfo();
206  delete mInfo;
207  delete mObjFile;
208  delete mLoader;
209}
210