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/MetadataExtractor.h" 18 19 #include "bcinfo/BitcodeWrapper.h" 20 21 #define LOG_TAG "bcinfo" 22 #include <cutils/log.h> 23 24 #include "llvm/ADT/OwningPtr.h" 25 #include "llvm/Bitcode/ReaderWriter.h" 26 #include "llvm/Constants.h" 27 #include "llvm/LLVMContext.h" 28 #include "llvm/Module.h" 29 #include "llvm/Support/MemoryBuffer.h" 30 31 #include <cstdlib> 32 33 namespace bcinfo { 34 35 // Name of metadata node where pragma info resides (should be synced with 36 // slang.cpp) 37 static const llvm::StringRef PragmaMetadataName = "#pragma"; 38 39 // Name of metadata node where exported variable names reside (should be 40 // synced with slang_rs_metadata.h) 41 static const llvm::StringRef ExportVarMetadataName = "#rs_export_var"; 42 43 // Name of metadata node where exported function names reside (should be 44 // synced with slang_rs_metadata.h) 45 static const llvm::StringRef ExportFuncMetadataName = "#rs_export_func"; 46 47 // Name of metadata node where exported ForEach name information resides 48 // (should be synced with slang_rs_metadata.h) 49 static const llvm::StringRef ExportForEachNameMetadataName = 50 "#rs_export_foreach_name"; 51 52 // Name of metadata node where exported ForEach signature information resides 53 // (should be synced with slang_rs_metadata.h) 54 static const llvm::StringRef ExportForEachMetadataName = "#rs_export_foreach"; 55 56 // Name of metadata node where RS object slot info resides (should be 57 // synced with slang_rs_metadata.h) 58 static const llvm::StringRef ObjectSlotMetadataName = "#rs_object_slots"; 59 60 61 MetadataExtractor::MetadataExtractor(const char *bitcode, size_t bitcodeSize) 62 : mModule(NULL), mBitcode(bitcode), mBitcodeSize(bitcodeSize), 63 mExportVarCount(0), mExportFuncCount(0), mExportForEachSignatureCount(0), 64 mExportVarNameList(NULL), mExportFuncNameList(NULL), 65 mExportForEachNameList(NULL), mExportForEachSignatureList(NULL), 66 mPragmaCount(0), mPragmaKeyList(NULL), mPragmaValueList(NULL), 67 mObjectSlotCount(0), mObjectSlotList(NULL), 68 mRSFloatPrecision(RS_FP_Full) { 69 BitcodeWrapper wrapper(bitcode, bitcodeSize); 70 mCompilerVersion = wrapper.getCompilerVersion(); 71 mOptimizationLevel = wrapper.getOptimizationLevel(); 72 } 73 74 75 MetadataExtractor::MetadataExtractor(const llvm::Module *module) 76 : mModule(module), mBitcode(NULL), mBitcodeSize(0), mExportVarCount(0), 77 mExportFuncCount(0), mExportForEachSignatureCount(0), 78 mExportVarNameList(NULL), mExportFuncNameList(NULL), 79 mExportForEachNameList(NULL), mExportForEachSignatureList(NULL), 80 mPragmaCount(0), mPragmaKeyList(NULL), mPragmaValueList(NULL), 81 mObjectSlotCount(0), mObjectSlotList(NULL), 82 mRSFloatPrecision(RS_FP_Full) { 83 mCompilerVersion = 0; 84 mOptimizationLevel = 3; 85 } 86 87 88 MetadataExtractor::~MetadataExtractor() { 89 if (mExportVarNameList) { 90 for (size_t i = 0; i < mExportVarCount; i++) { 91 delete [] mExportVarNameList[i]; 92 mExportVarNameList[i] = NULL; 93 } 94 } 95 delete [] mExportVarNameList; 96 mExportVarNameList = NULL; 97 98 if (mExportFuncNameList) { 99 for (size_t i = 0; i < mExportFuncCount; i++) { 100 delete [] mExportFuncNameList[i]; 101 mExportFuncNameList[i] = NULL; 102 } 103 } 104 delete [] mExportFuncNameList; 105 mExportFuncNameList = NULL; 106 107 if (mExportForEachNameList) { 108 for (size_t i = 0; i < mExportForEachSignatureCount; i++) { 109 delete [] mExportForEachNameList[i]; 110 mExportForEachNameList[i] = NULL; 111 } 112 } 113 delete [] mExportForEachNameList; 114 mExportForEachNameList = NULL; 115 116 delete [] mExportForEachSignatureList; 117 mExportForEachSignatureList = NULL; 118 119 for (size_t i = 0; i < mPragmaCount; i++) { 120 if (mPragmaKeyList) { 121 delete [] mPragmaKeyList[i]; 122 mPragmaKeyList[i] = NULL; 123 } 124 if (mPragmaValueList) { 125 delete [] mPragmaValueList[i]; 126 mPragmaValueList[i] = NULL; 127 } 128 } 129 delete [] mPragmaKeyList; 130 mPragmaKeyList = NULL; 131 delete [] mPragmaValueList; 132 mPragmaValueList = NULL; 133 134 delete [] mObjectSlotList; 135 mObjectSlotList = NULL; 136 137 return; 138 } 139 140 141 bool MetadataExtractor::populateObjectSlotMetadata( 142 const llvm::NamedMDNode *ObjectSlotMetadata) { 143 if (!ObjectSlotMetadata) { 144 return true; 145 } 146 147 mObjectSlotCount = ObjectSlotMetadata->getNumOperands(); 148 149 if (!mObjectSlotCount) { 150 return true; 151 } 152 153 uint32_t *TmpSlotList = new uint32_t[mObjectSlotCount]; 154 memset(TmpSlotList, 0, mObjectSlotCount * sizeof(*TmpSlotList)); 155 156 for (size_t i = 0; i < mObjectSlotCount; i++) { 157 llvm::MDNode *ObjectSlot = ObjectSlotMetadata->getOperand(i); 158 if (ObjectSlot != NULL && ObjectSlot->getNumOperands() == 1) { 159 llvm::Value *SlotMDS = ObjectSlot->getOperand(0); 160 if (SlotMDS->getValueID() == llvm::Value::MDStringVal) { 161 llvm::StringRef Slot = 162 static_cast<llvm::MDString*>(SlotMDS)->getString(); 163 uint32_t USlot = 0; 164 if (Slot.getAsInteger(10, USlot)) { 165 ALOGE("Non-integer object slot value '%s'", Slot.str().c_str()); 166 return false; 167 } 168 TmpSlotList[i] = USlot; 169 } 170 } 171 } 172 173 mObjectSlotList = TmpSlotList; 174 175 return true; 176 } 177 178 179 static const char *createStringFromValue(llvm::Value *v) { 180 if (v->getValueID() != llvm::Value::MDStringVal) { 181 return NULL; 182 } 183 184 llvm::StringRef ref = static_cast<llvm::MDString*>(v)->getString(); 185 186 char *c = new char[ref.size() + 1]; 187 memcpy(c, ref.data(), ref.size()); 188 c[ref.size()] = '\0'; 189 190 return c; 191 } 192 193 194 void MetadataExtractor::populatePragmaMetadata( 195 const llvm::NamedMDNode *PragmaMetadata) { 196 if (!PragmaMetadata) { 197 return; 198 } 199 200 mPragmaCount = PragmaMetadata->getNumOperands(); 201 if (!mPragmaCount) { 202 return; 203 } 204 205 const char **TmpKeyList = new const char*[mPragmaCount]; 206 const char **TmpValueList = new const char*[mPragmaCount]; 207 208 for (size_t i = 0; i < mPragmaCount; i++) { 209 llvm::MDNode *Pragma = PragmaMetadata->getOperand(i); 210 if (Pragma != NULL && Pragma->getNumOperands() == 2) { 211 llvm::Value *PragmaKeyMDS = Pragma->getOperand(0); 212 TmpKeyList[i] = createStringFromValue(PragmaKeyMDS); 213 llvm::Value *PragmaValueMDS = Pragma->getOperand(1); 214 TmpValueList[i] = createStringFromValue(PragmaValueMDS); 215 } 216 } 217 218 mPragmaKeyList = TmpKeyList; 219 mPragmaValueList = TmpValueList; 220 221 // Check to see if we have any FP precision-related pragmas. 222 std::string Relaxed("rs_fp_relaxed"); 223 std::string Imprecise("rs_fp_imprecise"); 224 bool RelaxedPragmaSeen = false; 225 bool ImprecisePragmaSeen = false; 226 227 for (size_t i = 0; i < mPragmaCount; i++) { 228 if (!Relaxed.compare(mPragmaKeyList[i])) { 229 if (RelaxedPragmaSeen || ImprecisePragmaSeen) { 230 ALOGE("Multiple float precision pragmas specified!"); 231 } 232 RelaxedPragmaSeen = true; 233 } else if (!Imprecise.compare(mPragmaKeyList[i])) { 234 if (RelaxedPragmaSeen || ImprecisePragmaSeen) { 235 ALOGE("Multiple float precision pragmas specified!"); 236 } 237 ImprecisePragmaSeen = true; 238 } 239 } 240 241 // Imprecise is selected over Relaxed precision. 242 // In the absence of both, we stick to the default Full precision. 243 if (ImprecisePragmaSeen) { 244 mRSFloatPrecision = RS_FP_Imprecise; 245 } else if (RelaxedPragmaSeen) { 246 mRSFloatPrecision = RS_FP_Relaxed; 247 } 248 249 return; 250 } 251 252 253 bool MetadataExtractor::populateVarNameMetadata( 254 const llvm::NamedMDNode *VarNameMetadata) { 255 if (!VarNameMetadata) { 256 return true; 257 } 258 259 mExportVarCount = VarNameMetadata->getNumOperands(); 260 if (!mExportVarCount) { 261 return true; 262 } 263 264 const char **TmpNameList = new const char *[mExportVarCount]; 265 266 for (size_t i = 0; i < mExportVarCount; i++) { 267 llvm::MDNode *Name = VarNameMetadata->getOperand(i); 268 if (Name != NULL && Name->getNumOperands() > 1) { 269 TmpNameList[i] = createStringFromValue(Name->getOperand(0)); 270 } 271 } 272 273 mExportVarNameList = TmpNameList; 274 275 return true; 276 } 277 278 279 bool MetadataExtractor::populateFuncNameMetadata( 280 const llvm::NamedMDNode *FuncNameMetadata) { 281 if (!FuncNameMetadata) { 282 return true; 283 } 284 285 mExportFuncCount = FuncNameMetadata->getNumOperands(); 286 if (!mExportFuncCount) { 287 return true; 288 } 289 290 const char **TmpNameList = new const char*[mExportFuncCount]; 291 292 for (size_t i = 0; i < mExportFuncCount; i++) { 293 llvm::MDNode *Name = FuncNameMetadata->getOperand(i); 294 if (Name != NULL && Name->getNumOperands() == 1) { 295 TmpNameList[i] = createStringFromValue(Name->getOperand(0)); 296 } 297 } 298 299 mExportFuncNameList = TmpNameList; 300 301 return true; 302 } 303 304 305 bool MetadataExtractor::populateForEachMetadata( 306 const llvm::NamedMDNode *Names, 307 const llvm::NamedMDNode *Signatures) { 308 if (!Names && !Signatures) { 309 // Handle legacy case for pre-ICS bitcode that doesn't contain a metadata 310 // section for ForEach. We generate a full signature for a "root" function 311 // which means that we need to set the bottom 5 bits in the mask. 312 mExportForEachSignatureCount = 1; 313 char **TmpNameList = new char*[mExportForEachSignatureCount]; 314 TmpNameList[0] = new char[5]; 315 strncpy(TmpNameList[0], "root", 5); 316 317 uint32_t *TmpSigList = new uint32_t[mExportForEachSignatureCount]; 318 TmpSigList[0] = 0x1f; 319 320 mExportForEachNameList = (const char**)TmpNameList; 321 mExportForEachSignatureList = TmpSigList; 322 return true; 323 } 324 325 if (Signatures) { 326 mExportForEachSignatureCount = Signatures->getNumOperands(); 327 if (!mExportForEachSignatureCount) { 328 return true; 329 } 330 } else { 331 mExportForEachSignatureCount = 0; 332 mExportForEachSignatureList = NULL; 333 return true; 334 } 335 336 uint32_t *TmpSigList = new uint32_t[mExportForEachSignatureCount]; 337 const char **TmpNameList = new const char*[mExportForEachSignatureCount]; 338 339 for (size_t i = 0; i < mExportForEachSignatureCount; i++) { 340 llvm::MDNode *SigNode = Signatures->getOperand(i); 341 if (SigNode != NULL && SigNode->getNumOperands() == 1) { 342 llvm::Value *SigVal = SigNode->getOperand(0); 343 if (SigVal->getValueID() == llvm::Value::MDStringVal) { 344 llvm::StringRef SigString = 345 static_cast<llvm::MDString*>(SigVal)->getString(); 346 uint32_t Signature = 0; 347 if (SigString.getAsInteger(10, Signature)) { 348 ALOGE("Non-integer signature value '%s'", SigString.str().c_str()); 349 return false; 350 } 351 TmpSigList[i] = Signature; 352 } 353 } 354 } 355 356 if (Names) { 357 for (size_t i = 0; i < mExportForEachSignatureCount; i++) { 358 llvm::MDNode *Name = Names->getOperand(i); 359 if (Name != NULL && Name->getNumOperands() == 1) { 360 TmpNameList[i] = createStringFromValue(Name->getOperand(0)); 361 } 362 } 363 } else { 364 if (mExportForEachSignatureCount != 1) { 365 ALOGE("mExportForEachSignatureCount = %zu, but should be 1", 366 mExportForEachSignatureCount); 367 } 368 char *RootName = new char[5]; 369 strncpy(RootName, "root", 5); 370 TmpNameList[0] = RootName; 371 } 372 373 mExportForEachNameList = TmpNameList; 374 mExportForEachSignatureList = TmpSigList; 375 376 return true; 377 } 378 379 380 bool MetadataExtractor::extract() { 381 if (!(mBitcode && mBitcodeSize) && !mModule) { 382 ALOGE("Invalid/empty bitcode/module"); 383 return false; 384 } 385 386 llvm::OwningPtr<llvm::LLVMContext> mContext; 387 388 if (!mModule) { 389 mContext.reset(new llvm::LLVMContext()); 390 llvm::OwningPtr<llvm::MemoryBuffer> MEM( 391 llvm::MemoryBuffer::getMemBuffer( 392 llvm::StringRef(mBitcode, mBitcodeSize), "", false)); 393 std::string error; 394 395 // Module ownership is handled by the context, so we don't need to free it. 396 mModule = llvm::ParseBitcodeFile(MEM.get(), *mContext, &error); 397 if (!mModule) { 398 ALOGE("Could not parse bitcode file"); 399 ALOGE("%s", error.c_str()); 400 return false; 401 } 402 } 403 404 const llvm::NamedMDNode *ExportVarMetadata = 405 mModule->getNamedMetadata(ExportVarMetadataName); 406 const llvm::NamedMDNode *ExportFuncMetadata = 407 mModule->getNamedMetadata(ExportFuncMetadataName); 408 const llvm::NamedMDNode *ExportForEachNameMetadata = 409 mModule->getNamedMetadata(ExportForEachNameMetadataName); 410 const llvm::NamedMDNode *ExportForEachMetadata = 411 mModule->getNamedMetadata(ExportForEachMetadataName); 412 const llvm::NamedMDNode *PragmaMetadata = 413 mModule->getNamedMetadata(PragmaMetadataName); 414 const llvm::NamedMDNode *ObjectSlotMetadata = 415 mModule->getNamedMetadata(ObjectSlotMetadataName); 416 417 418 if (!populateVarNameMetadata(ExportVarMetadata)) { 419 ALOGE("Could not populate export variable metadata"); 420 return false; 421 } 422 423 if (!populateFuncNameMetadata(ExportFuncMetadata)) { 424 ALOGE("Could not populate export function metadata"); 425 return false; 426 } 427 428 if (!populateForEachMetadata(ExportForEachNameMetadata, 429 ExportForEachMetadata)) { 430 ALOGE("Could not populate ForEach signature metadata"); 431 return false; 432 } 433 434 populatePragmaMetadata(PragmaMetadata); 435 436 if (!populateObjectSlotMetadata(ObjectSlotMetadata)) { 437 ALOGE("Could not populate object slot metadata"); 438 return false; 439 } 440 441 return true; 442 } 443 444 } // namespace bcinfo 445 446