• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2011-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 <bcinfo/BitcodeTranslator.h>
18 #include <bcinfo/BitcodeWrapper.h>
19 #include <bcinfo/MetadataExtractor.h>
20 
21 #include <llvm/ADT/OwningPtr.h>
22 #include <llvm/ADT/StringRef.h>
23 #include <llvm/Assembly/AssemblyAnnotationWriter.h>
24 #include <llvm/Bitcode/ReaderWriter.h>
25 #include <llvm/IR/LLVMContext.h>
26 #include <llvm/IR/Module.h>
27 #include <llvm/Support/ManagedStatic.h>
28 #include <llvm/Support/MemoryBuffer.h>
29 #include <llvm/Support/ToolOutputFile.h>
30 
31 #include <ctype.h>
32 #include <dlfcn.h>
33 #include <stdarg.h>
34 #include <stdint.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <getopt.h>
39 
40 #include <errno.h>
41 #include <sys/stat.h>
42 #include <sys/types.h>
43 
44 #include <unistd.h>
45 
46 #include <string>
47 #include <vector>
48 
49 // This file corresponds to the standalone bcinfo tool. It prints a variety of
50 // information about a supplied bitcode input file.
51 
52 std::string inFile;
53 std::string outFile;
54 std::string infoFile;
55 
56 extern int opterr;
57 extern int optind;
58 
59 bool translateFlag = false;
60 bool infoFlag = false;
61 bool verbose = true;
62 
parseOption(int argc,char ** argv)63 static int parseOption(int argc, char** argv) {
64   int c;
65   while ((c = getopt(argc, argv, "itv")) != -1) {
66     opterr = 0;
67 
68     switch(c) {
69       case '?':
70         // ignore any error
71         break;
72 
73       case 't':
74         translateFlag = true;
75         break;
76 
77       case 'i':
78         // Turn off verbose so that we only generate the .info file.
79         infoFlag = true;
80         verbose = false;
81         break;
82 
83       case 'v':
84         verbose = true;
85         break;
86 
87       default:
88         // Critical error occurs
89         return 0;
90         break;
91     }
92   }
93 
94   if(optind >= argc) {
95     fprintf(stderr, "input file required\n");
96     return 0;
97   }
98 
99   inFile = argv[optind];
100 
101   int l = inFile.length();
102   if (l > 3 && inFile[l-3] == '.' && inFile[l-2] == 'b' && inFile[l-1] == 'c') {
103     outFile = std::string(inFile.begin(), inFile.end() - 3) + ".ll";
104     infoFile = std::string(inFile.begin(), inFile.end() - 3) + ".bcinfo";
105   } else {
106     outFile = inFile + ".ll";
107     infoFile = inFile + ".bcinfo";
108   }
109   return 1;
110 }
111 
112 
dumpInfo(bcinfo::MetadataExtractor * ME)113 static int dumpInfo(bcinfo::MetadataExtractor *ME) {
114   if (!ME) {
115     return 1;
116   }
117 
118   FILE *info = fopen(infoFile.c_str(), "w");
119   if (!info) {
120     fprintf(stderr, "Could not open info file %s\n", infoFile.c_str());
121     return 2;
122   }
123 
124   fprintf(info, "exportVarCount: %u\n", ME->getExportVarCount());
125   const char **varNameList = ME->getExportVarNameList();
126   for (size_t i = 0; i < ME->getExportVarCount(); i++) {
127     fprintf(info, "%s\n", varNameList[i]);
128   }
129 
130   fprintf(info, "exportFuncCount: %u\n", ME->getExportFuncCount());
131   const char **funcNameList = ME->getExportFuncNameList();
132   for (size_t i = 0; i < ME->getExportFuncCount(); i++) {
133     fprintf(info, "%s\n", funcNameList[i]);
134   }
135 
136   fprintf(info, "exportForEachCount: %u\n",
137           ME->getExportForEachSignatureCount());
138   const char **nameList = ME->getExportForEachNameList();
139   const uint32_t *sigList = ME->getExportForEachSignatureList();
140   for (size_t i = 0; i < ME->getExportForEachSignatureCount(); i++) {
141     fprintf(info, "%u - %s\n", sigList[i], nameList[i]);
142   }
143 
144   fprintf(info, "objectSlotCount: %u\n", ME->getObjectSlotCount());
145   const uint32_t *slotList = ME->getObjectSlotList();
146   for (size_t i = 0; i < ME->getObjectSlotCount(); i++) {
147     fprintf(info, "%u\n", slotList[i]);
148   }
149 
150   fclose(info);
151   return 0;
152 }
153 
154 
dumpMetadata(bcinfo::MetadataExtractor * ME)155 static void dumpMetadata(bcinfo::MetadataExtractor *ME) {
156   if (!ME) {
157     return;
158   }
159 
160   printf("RSFloatPrecision: ");
161   switch (ME->getRSFloatPrecision()) {
162   case bcinfo::RS_FP_Full:
163     printf("Full\n\n");
164     break;
165   case bcinfo::RS_FP_Relaxed:
166     printf("Relaxed\n\n");
167     break;
168   case bcinfo::RS_FP_Imprecise:
169     printf("Imprecise\n\n");
170     break;
171   default:
172     printf("UNKNOWN\n\n");
173     break;
174   }
175 
176   printf("exportVarCount: %u\n", ME->getExportVarCount());
177   const char **varNameList = ME->getExportVarNameList();
178   for (size_t i = 0; i < ME->getExportVarCount(); i++) {
179     printf("var[%u]: %s\n", i, varNameList[i]);
180   }
181   printf("\n");
182 
183   printf("exportFuncCount: %u\n", ME->getExportFuncCount());
184   const char **funcNameList = ME->getExportFuncNameList();
185   for (size_t i = 0; i < ME->getExportFuncCount(); i++) {
186     printf("func[%u]: %s\n", i, funcNameList[i]);
187   }
188   printf("\n");
189 
190   printf("exportForEachSignatureCount: %u\n",
191          ME->getExportForEachSignatureCount());
192   const char **nameList = ME->getExportForEachNameList();
193   const uint32_t *sigList = ME->getExportForEachSignatureList();
194   for (size_t i = 0; i < ME->getExportForEachSignatureCount(); i++) {
195     printf("exportForEachSignatureList[%u]: %s - %u\n", i, nameList[i],
196            sigList[i]);
197   }
198   printf("\n");
199 
200   printf("pragmaCount: %u\n", ME->getPragmaCount());
201   const char **keyList = ME->getPragmaKeyList();
202   const char **valueList = ME->getPragmaValueList();
203   for (size_t i = 0; i < ME->getPragmaCount(); i++) {
204     printf("pragma[%u]: %s - %s\n", i, keyList[i], valueList[i]);
205   }
206   printf("\n");
207 
208   printf("objectSlotCount: %u\n", ME->getObjectSlotCount());
209   const uint32_t *slotList = ME->getObjectSlotList();
210   for (size_t i = 0; i < ME->getObjectSlotCount(); i++) {
211     printf("objectSlotList[%u]: %u\n", i, slotList[i]);
212   }
213   printf("\n");
214 
215   return;
216 }
217 
218 
readBitcode(const char ** bitcode)219 static size_t readBitcode(const char **bitcode) {
220   if (!inFile.length()) {
221     fprintf(stderr, "input file required\n");
222     return 0;
223   }
224 
225   struct stat statInFile;
226   if (stat(inFile.c_str(), &statInFile) < 0) {
227     fprintf(stderr, "Unable to stat input file: %s\n", strerror(errno));
228     return 0;
229   }
230 
231   if (!S_ISREG(statInFile.st_mode)) {
232     fprintf(stderr, "Input file should be a regular file.\n");
233     return 0;
234   }
235 
236   FILE *in = fopen(inFile.c_str(), "r");
237   if (!in) {
238     fprintf(stderr, "Could not open input file %s\n", inFile.c_str());
239     return 0;
240   }
241 
242   size_t bitcodeSize = statInFile.st_size;
243 
244   *bitcode = (const char*) calloc(1, bitcodeSize + 1);
245   size_t nread = fread((void*) *bitcode, 1, bitcodeSize, in);
246 
247   if (nread != bitcodeSize)
248       fprintf(stderr, "Could not read all of file %s\n", inFile.c_str());
249 
250   fclose(in);
251   return nread;
252 }
253 
254 
releaseBitcode(const char ** bitcode)255 static void releaseBitcode(const char **bitcode) {
256   if (bitcode && *bitcode) {
257     free((void*) *bitcode);
258     *bitcode = NULL;
259   }
260   return;
261 }
262 
263 
main(int argc,char ** argv)264 int main(int argc, char** argv) {
265   if(!parseOption(argc, argv)) {
266     fprintf(stderr, "failed to parse option\n");
267     return 1;
268   }
269 
270   const char *bitcode = NULL;
271   size_t bitcodeSize = readBitcode(&bitcode);
272 
273   unsigned int version = 0;
274 
275   bcinfo::BitcodeWrapper bcWrapper((const char *)bitcode, bitcodeSize);
276   if (bcWrapper.getBCFileType() == bcinfo::BC_WRAPPER) {
277     version = bcWrapper.getTargetAPI();
278     if (verbose) {
279       printf("Found bitcodeWrapper\n");
280     }
281   } else if (translateFlag) {
282     version = 12;
283   }
284 
285   if (verbose) {
286     printf("targetAPI: %u\n", version);
287     printf("compilerVersion: %u\n", bcWrapper.getCompilerVersion());
288     printf("optimizationLevel: %u\n\n", bcWrapper.getOptimizationLevel());
289   }
290 
291   llvm::OwningPtr<bcinfo::BitcodeTranslator> BT;
292   BT.reset(new bcinfo::BitcodeTranslator(bitcode, bitcodeSize, version));
293   if (!BT->translate()) {
294     fprintf(stderr, "failed to translate bitcode\n");
295     return 3;
296   }
297 
298   llvm::OwningPtr<bcinfo::MetadataExtractor> ME;
299   ME.reset(new bcinfo::MetadataExtractor(BT->getTranslatedBitcode(),
300                                          BT->getTranslatedBitcodeSize()));
301   if (!ME->extract()) {
302     fprintf(stderr, "failed to get metadata\n");
303     return 4;
304   }
305 
306   if (verbose) {
307     dumpMetadata(ME.get());
308 
309     const char *translatedBitcode = BT->getTranslatedBitcode();
310     size_t translatedBitcodeSize = BT->getTranslatedBitcodeSize();
311 
312     llvm::LLVMContext &ctx = llvm::getGlobalContext();
313     llvm::llvm_shutdown_obj called_on_exit;
314 
315     llvm::OwningPtr<llvm::MemoryBuffer> mem;
316 
317     mem.reset(llvm::MemoryBuffer::getMemBuffer(
318         llvm::StringRef(translatedBitcode, translatedBitcodeSize),
319         inFile.c_str(), false));
320 
321     llvm::OwningPtr<llvm::Module> module;
322     std::string errmsg;
323     module.reset(llvm::ParseBitcodeFile(mem.get(), ctx, &errmsg));
324     if (module.get() != 0 && module->MaterializeAllPermanently(&errmsg)) {
325       module.reset();
326     }
327 
328     if (module.get() == 0) {
329       if (errmsg.size()) {
330         fprintf(stderr, "error: %s\n", errmsg.c_str());
331       } else {
332         fprintf(stderr, "error: failed to parse bitcode file\n");
333       }
334       return 5;
335     }
336 
337     llvm::OwningPtr<llvm::tool_output_file> tof(
338         new llvm::tool_output_file(outFile.c_str(), errmsg,
339                                    llvm::sys::fs::F_Binary));
340     llvm::OwningPtr<llvm::AssemblyAnnotationWriter> ann;
341     module->print(tof->os(), ann.get());
342 
343     tof->keep();
344   }
345 
346   if (infoFlag) {
347     if (dumpInfo(ME.get()) != 0) {
348       fprintf(stderr, "Error dumping info file\n");
349       return 6;
350     }
351   }
352 
353   releaseBitcode(&bitcode);
354 
355   return 0;
356 }
357