1 //===- CoverageMappingReader.cpp - Code coverage mapping reader -----------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file contains support for reading coverage mapping data for 11 // instrumentation based coverage. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/ProfileData/Coverage/CoverageMappingReader.h" 16 #include "llvm/ADT/ArrayRef.h" 17 #include "llvm/ADT/DenseMap.h" 18 #include "llvm/ADT/STLExtras.h" 19 #include "llvm/ADT/SmallVector.h" 20 #include "llvm/ADT/StringRef.h" 21 #include "llvm/ADT/Triple.h" 22 #include "llvm/Object/Binary.h" 23 #include "llvm/Object/Error.h" 24 #include "llvm/Object/MachOUniversal.h" 25 #include "llvm/Object/ObjectFile.h" 26 #include "llvm/ProfileData/InstrProf.h" 27 #include "llvm/Support/Casting.h" 28 #include "llvm/Support/Debug.h" 29 #include "llvm/Support/Endian.h" 30 #include "llvm/Support/Error.h" 31 #include "llvm/Support/ErrorHandling.h" 32 #include "llvm/Support/LEB128.h" 33 #include "llvm/Support/MathExtras.h" 34 #include "llvm/Support/raw_ostream.h" 35 #include <vector> 36 37 using namespace llvm; 38 using namespace coverage; 39 using namespace object; 40 41 #define DEBUG_TYPE "coverage-mapping" 42 43 void CoverageMappingIterator::increment() { 44 if (ReadErr != coveragemap_error::success) 45 return; 46 47 // Check if all the records were read or if an error occurred while reading 48 // the next record. 49 if (auto E = Reader->readNextRecord(Record)) 50 handleAllErrors(std::move(E), [&](const CoverageMapError &CME) { 51 if (CME.get() == coveragemap_error::eof) 52 *this = CoverageMappingIterator(); 53 else 54 ReadErr = CME.get(); 55 }); 56 } 57 58 Error RawCoverageReader::readULEB128(uint64_t &Result) { 59 if (Data.empty()) 60 return make_error<CoverageMapError>(coveragemap_error::truncated); 61 unsigned N = 0; 62 Result = decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N); 63 if (N > Data.size()) 64 return make_error<CoverageMapError>(coveragemap_error::malformed); 65 Data = Data.substr(N); 66 return Error::success(); 67 } 68 69 Error RawCoverageReader::readIntMax(uint64_t &Result, uint64_t MaxPlus1) { 70 if (auto Err = readULEB128(Result)) 71 return Err; 72 if (Result >= MaxPlus1) 73 return make_error<CoverageMapError>(coveragemap_error::malformed); 74 return Error::success(); 75 } 76 77 Error RawCoverageReader::readSize(uint64_t &Result) { 78 if (auto Err = readULEB128(Result)) 79 return Err; 80 // Sanity check the number. 81 if (Result > Data.size()) 82 return make_error<CoverageMapError>(coveragemap_error::malformed); 83 return Error::success(); 84 } 85 86 Error RawCoverageReader::readString(StringRef &Result) { 87 uint64_t Length; 88 if (auto Err = readSize(Length)) 89 return Err; 90 Result = Data.substr(0, Length); 91 Data = Data.substr(Length); 92 return Error::success(); 93 } 94 95 Error RawCoverageFilenamesReader::read() { 96 uint64_t NumFilenames; 97 if (auto Err = readSize(NumFilenames)) 98 return Err; 99 for (size_t I = 0; I < NumFilenames; ++I) { 100 StringRef Filename; 101 if (auto Err = readString(Filename)) 102 return Err; 103 Filenames.push_back(Filename); 104 } 105 return Error::success(); 106 } 107 108 Error RawCoverageMappingReader::decodeCounter(unsigned Value, Counter &C) { 109 auto Tag = Value & Counter::EncodingTagMask; 110 switch (Tag) { 111 case Counter::Zero: 112 C = Counter::getZero(); 113 return Error::success(); 114 case Counter::CounterValueReference: 115 C = Counter::getCounter(Value >> Counter::EncodingTagBits); 116 return Error::success(); 117 default: 118 break; 119 } 120 Tag -= Counter::Expression; 121 switch (Tag) { 122 case CounterExpression::Subtract: 123 case CounterExpression::Add: { 124 auto ID = Value >> Counter::EncodingTagBits; 125 if (ID >= Expressions.size()) 126 return make_error<CoverageMapError>(coveragemap_error::malformed); 127 Expressions[ID].Kind = CounterExpression::ExprKind(Tag); 128 C = Counter::getExpression(ID); 129 break; 130 } 131 default: 132 return make_error<CoverageMapError>(coveragemap_error::malformed); 133 } 134 return Error::success(); 135 } 136 137 Error RawCoverageMappingReader::readCounter(Counter &C) { 138 uint64_t EncodedCounter; 139 if (auto Err = 140 readIntMax(EncodedCounter, std::numeric_limits<unsigned>::max())) 141 return Err; 142 if (auto Err = decodeCounter(EncodedCounter, C)) 143 return Err; 144 return Error::success(); 145 } 146 147 static const unsigned EncodingExpansionRegionBit = 1 148 << Counter::EncodingTagBits; 149 150 /// Read the sub-array of regions for the given inferred file id. 151 /// \param NumFileIDs the number of file ids that are defined for this 152 /// function. 153 Error RawCoverageMappingReader::readMappingRegionsSubArray( 154 std::vector<CounterMappingRegion> &MappingRegions, unsigned InferredFileID, 155 size_t NumFileIDs) { 156 uint64_t NumRegions; 157 if (auto Err = readSize(NumRegions)) 158 return Err; 159 unsigned LineStart = 0; 160 for (size_t I = 0; I < NumRegions; ++I) { 161 Counter C; 162 CounterMappingRegion::RegionKind Kind = CounterMappingRegion::CodeRegion; 163 164 // Read the combined counter + region kind. 165 uint64_t EncodedCounterAndRegion; 166 if (auto Err = readIntMax(EncodedCounterAndRegion, 167 std::numeric_limits<unsigned>::max())) 168 return Err; 169 unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask; 170 uint64_t ExpandedFileID = 0; 171 if (Tag != Counter::Zero) { 172 if (auto Err = decodeCounter(EncodedCounterAndRegion, C)) 173 return Err; 174 } else { 175 // Is it an expansion region? 176 if (EncodedCounterAndRegion & EncodingExpansionRegionBit) { 177 Kind = CounterMappingRegion::ExpansionRegion; 178 ExpandedFileID = EncodedCounterAndRegion >> 179 Counter::EncodingCounterTagAndExpansionRegionTagBits; 180 if (ExpandedFileID >= NumFileIDs) 181 return make_error<CoverageMapError>(coveragemap_error::malformed); 182 } else { 183 switch (EncodedCounterAndRegion >> 184 Counter::EncodingCounterTagAndExpansionRegionTagBits) { 185 case CounterMappingRegion::CodeRegion: 186 // Don't do anything when we have a code region with a zero counter. 187 break; 188 case CounterMappingRegion::SkippedRegion: 189 Kind = CounterMappingRegion::SkippedRegion; 190 break; 191 default: 192 return make_error<CoverageMapError>(coveragemap_error::malformed); 193 } 194 } 195 } 196 197 // Read the source range. 198 uint64_t LineStartDelta, ColumnStart, NumLines, ColumnEnd; 199 if (auto Err = 200 readIntMax(LineStartDelta, std::numeric_limits<unsigned>::max())) 201 return Err; 202 if (auto Err = readULEB128(ColumnStart)) 203 return Err; 204 if (ColumnStart > std::numeric_limits<unsigned>::max()) 205 return make_error<CoverageMapError>(coveragemap_error::malformed); 206 if (auto Err = readIntMax(NumLines, std::numeric_limits<unsigned>::max())) 207 return Err; 208 if (auto Err = readIntMax(ColumnEnd, std::numeric_limits<unsigned>::max())) 209 return Err; 210 LineStart += LineStartDelta; 211 212 // If the high bit of ColumnEnd is set, this is a gap region. 213 if (ColumnEnd & (1U << 31)) { 214 Kind = CounterMappingRegion::GapRegion; 215 ColumnEnd &= ~(1U << 31); 216 } 217 218 // Adjust the column locations for the empty regions that are supposed to 219 // cover whole lines. Those regions should be encoded with the 220 // column range (1 -> std::numeric_limits<unsigned>::max()), but because 221 // the encoded std::numeric_limits<unsigned>::max() is several bytes long, 222 // we set the column range to (0 -> 0) to ensure that the column start and 223 // column end take up one byte each. 224 // The std::numeric_limits<unsigned>::max() is used to represent a column 225 // position at the end of the line without knowing the length of that line. 226 if (ColumnStart == 0 && ColumnEnd == 0) { 227 ColumnStart = 1; 228 ColumnEnd = std::numeric_limits<unsigned>::max(); 229 } 230 231 LLVM_DEBUG({ 232 dbgs() << "Counter in file " << InferredFileID << " " << LineStart << ":" 233 << ColumnStart << " -> " << (LineStart + NumLines) << ":" 234 << ColumnEnd << ", "; 235 if (Kind == CounterMappingRegion::ExpansionRegion) 236 dbgs() << "Expands to file " << ExpandedFileID; 237 else 238 CounterMappingContext(Expressions).dump(C, dbgs()); 239 dbgs() << "\n"; 240 }); 241 242 auto CMR = CounterMappingRegion(C, InferredFileID, ExpandedFileID, 243 LineStart, ColumnStart, 244 LineStart + NumLines, ColumnEnd, Kind); 245 if (CMR.startLoc() > CMR.endLoc()) 246 return make_error<CoverageMapError>(coveragemap_error::malformed); 247 MappingRegions.push_back(CMR); 248 } 249 return Error::success(); 250 } 251 252 Error RawCoverageMappingReader::read() { 253 // Read the virtual file mapping. 254 SmallVector<unsigned, 8> VirtualFileMapping; 255 uint64_t NumFileMappings; 256 if (auto Err = readSize(NumFileMappings)) 257 return Err; 258 for (size_t I = 0; I < NumFileMappings; ++I) { 259 uint64_t FilenameIndex; 260 if (auto Err = readIntMax(FilenameIndex, TranslationUnitFilenames.size())) 261 return Err; 262 VirtualFileMapping.push_back(FilenameIndex); 263 } 264 265 // Construct the files using unique filenames and virtual file mapping. 266 for (auto I : VirtualFileMapping) { 267 Filenames.push_back(TranslationUnitFilenames[I]); 268 } 269 270 // Read the expressions. 271 uint64_t NumExpressions; 272 if (auto Err = readSize(NumExpressions)) 273 return Err; 274 // Create an array of dummy expressions that get the proper counters 275 // when the expressions are read, and the proper kinds when the counters 276 // are decoded. 277 Expressions.resize( 278 NumExpressions, 279 CounterExpression(CounterExpression::Subtract, Counter(), Counter())); 280 for (size_t I = 0; I < NumExpressions; ++I) { 281 if (auto Err = readCounter(Expressions[I].LHS)) 282 return Err; 283 if (auto Err = readCounter(Expressions[I].RHS)) 284 return Err; 285 } 286 287 // Read the mapping regions sub-arrays. 288 for (unsigned InferredFileID = 0, S = VirtualFileMapping.size(); 289 InferredFileID < S; ++InferredFileID) { 290 if (auto Err = readMappingRegionsSubArray(MappingRegions, InferredFileID, 291 VirtualFileMapping.size())) 292 return Err; 293 } 294 295 // Set the counters for the expansion regions. 296 // i.e. Counter of expansion region = counter of the first region 297 // from the expanded file. 298 // Perform multiple passes to correctly propagate the counters through 299 // all the nested expansion regions. 300 SmallVector<CounterMappingRegion *, 8> FileIDExpansionRegionMapping; 301 FileIDExpansionRegionMapping.resize(VirtualFileMapping.size(), nullptr); 302 for (unsigned Pass = 1, S = VirtualFileMapping.size(); Pass < S; ++Pass) { 303 for (auto &R : MappingRegions) { 304 if (R.Kind != CounterMappingRegion::ExpansionRegion) 305 continue; 306 assert(!FileIDExpansionRegionMapping[R.ExpandedFileID]); 307 FileIDExpansionRegionMapping[R.ExpandedFileID] = &R; 308 } 309 for (auto &R : MappingRegions) { 310 if (FileIDExpansionRegionMapping[R.FileID]) { 311 FileIDExpansionRegionMapping[R.FileID]->Count = R.Count; 312 FileIDExpansionRegionMapping[R.FileID] = nullptr; 313 } 314 } 315 } 316 317 return Error::success(); 318 } 319 320 Expected<bool> RawCoverageMappingDummyChecker::isDummy() { 321 // A dummy coverage mapping data consists of just one region with zero count. 322 uint64_t NumFileMappings; 323 if (Error Err = readSize(NumFileMappings)) 324 return std::move(Err); 325 if (NumFileMappings != 1) 326 return false; 327 // We don't expect any specific value for the filename index, just skip it. 328 uint64_t FilenameIndex; 329 if (Error Err = 330 readIntMax(FilenameIndex, std::numeric_limits<unsigned>::max())) 331 return std::move(Err); 332 uint64_t NumExpressions; 333 if (Error Err = readSize(NumExpressions)) 334 return std::move(Err); 335 if (NumExpressions != 0) 336 return false; 337 uint64_t NumRegions; 338 if (Error Err = readSize(NumRegions)) 339 return std::move(Err); 340 if (NumRegions != 1) 341 return false; 342 uint64_t EncodedCounterAndRegion; 343 if (Error Err = readIntMax(EncodedCounterAndRegion, 344 std::numeric_limits<unsigned>::max())) 345 return std::move(Err); 346 unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask; 347 return Tag == Counter::Zero; 348 } 349 350 Error InstrProfSymtab::create(SectionRef &Section) { 351 if (auto EC = Section.getContents(Data)) 352 return errorCodeToError(EC); 353 Address = Section.getAddress(); 354 return Error::success(); 355 } 356 357 StringRef InstrProfSymtab::getFuncName(uint64_t Pointer, size_t Size) { 358 if (Pointer < Address) 359 return StringRef(); 360 auto Offset = Pointer - Address; 361 if (Offset + Size > Data.size()) 362 return StringRef(); 363 return Data.substr(Pointer - Address, Size); 364 } 365 366 // Check if the mapping data is a dummy, i.e. is emitted for an unused function. 367 static Expected<bool> isCoverageMappingDummy(uint64_t Hash, StringRef Mapping) { 368 // The hash value of dummy mapping records is always zero. 369 if (Hash) 370 return false; 371 return RawCoverageMappingDummyChecker(Mapping).isDummy(); 372 } 373 374 namespace { 375 376 struct CovMapFuncRecordReader { 377 virtual ~CovMapFuncRecordReader() = default; 378 379 // The interface to read coverage mapping function records for a module. 380 // 381 // \p Buf points to the buffer containing the \c CovHeader of the coverage 382 // mapping data associated with the module. 383 // 384 // Returns a pointer to the next \c CovHeader if it exists, or a pointer 385 // greater than \p End if not. 386 virtual Expected<const char *> readFunctionRecords(const char *Buf, 387 const char *End) = 0; 388 389 template <class IntPtrT, support::endianness Endian> 390 static Expected<std::unique_ptr<CovMapFuncRecordReader>> 391 get(CovMapVersion Version, InstrProfSymtab &P, 392 std::vector<BinaryCoverageReader::ProfileMappingRecord> &R, 393 std::vector<StringRef> &F); 394 }; 395 396 // A class for reading coverage mapping function records for a module. 397 template <CovMapVersion Version, class IntPtrT, support::endianness Endian> 398 class VersionedCovMapFuncRecordReader : public CovMapFuncRecordReader { 399 using FuncRecordType = 400 typename CovMapTraits<Version, IntPtrT>::CovMapFuncRecordType; 401 using NameRefType = typename CovMapTraits<Version, IntPtrT>::NameRefType; 402 403 // Maps function's name references to the indexes of their records 404 // in \c Records. 405 DenseMap<NameRefType, size_t> FunctionRecords; 406 InstrProfSymtab &ProfileNames; 407 std::vector<StringRef> &Filenames; 408 std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records; 409 410 // Add the record to the collection if we don't already have a record that 411 // points to the same function name. This is useful to ignore the redundant 412 // records for the functions with ODR linkage. 413 // In addition, prefer records with real coverage mapping data to dummy 414 // records, which were emitted for inline functions which were seen but 415 // not used in the corresponding translation unit. 416 Error insertFunctionRecordIfNeeded(const FuncRecordType *CFR, 417 StringRef Mapping, size_t FilenamesBegin) { 418 uint64_t FuncHash = CFR->template getFuncHash<Endian>(); 419 NameRefType NameRef = CFR->template getFuncNameRef<Endian>(); 420 auto InsertResult = 421 FunctionRecords.insert(std::make_pair(NameRef, Records.size())); 422 if (InsertResult.second) { 423 StringRef FuncName; 424 if (Error Err = CFR->template getFuncName<Endian>(ProfileNames, FuncName)) 425 return Err; 426 if (FuncName.empty()) 427 return make_error<InstrProfError>(instrprof_error::malformed); 428 Records.emplace_back(Version, FuncName, FuncHash, Mapping, FilenamesBegin, 429 Filenames.size() - FilenamesBegin); 430 return Error::success(); 431 } 432 // Update the existing record if it's a dummy and the new record is real. 433 size_t OldRecordIndex = InsertResult.first->second; 434 BinaryCoverageReader::ProfileMappingRecord &OldRecord = 435 Records[OldRecordIndex]; 436 Expected<bool> OldIsDummyExpected = isCoverageMappingDummy( 437 OldRecord.FunctionHash, OldRecord.CoverageMapping); 438 if (Error Err = OldIsDummyExpected.takeError()) 439 return Err; 440 if (!*OldIsDummyExpected) 441 return Error::success(); 442 Expected<bool> NewIsDummyExpected = 443 isCoverageMappingDummy(FuncHash, Mapping); 444 if (Error Err = NewIsDummyExpected.takeError()) 445 return Err; 446 if (*NewIsDummyExpected) 447 return Error::success(); 448 OldRecord.FunctionHash = FuncHash; 449 OldRecord.CoverageMapping = Mapping; 450 OldRecord.FilenamesBegin = FilenamesBegin; 451 OldRecord.FilenamesSize = Filenames.size() - FilenamesBegin; 452 return Error::success(); 453 } 454 455 public: 456 VersionedCovMapFuncRecordReader( 457 InstrProfSymtab &P, 458 std::vector<BinaryCoverageReader::ProfileMappingRecord> &R, 459 std::vector<StringRef> &F) 460 : ProfileNames(P), Filenames(F), Records(R) {} 461 462 ~VersionedCovMapFuncRecordReader() override = default; 463 464 Expected<const char *> readFunctionRecords(const char *Buf, 465 const char *End) override { 466 using namespace support; 467 468 if (Buf + sizeof(CovMapHeader) > End) 469 return make_error<CoverageMapError>(coveragemap_error::malformed); 470 auto CovHeader = reinterpret_cast<const CovMapHeader *>(Buf); 471 uint32_t NRecords = CovHeader->getNRecords<Endian>(); 472 uint32_t FilenamesSize = CovHeader->getFilenamesSize<Endian>(); 473 uint32_t CoverageSize = CovHeader->getCoverageSize<Endian>(); 474 assert((CovMapVersion)CovHeader->getVersion<Endian>() == Version); 475 Buf = reinterpret_cast<const char *>(CovHeader + 1); 476 477 // Skip past the function records, saving the start and end for later. 478 const char *FunBuf = Buf; 479 Buf += NRecords * sizeof(FuncRecordType); 480 const char *FunEnd = Buf; 481 482 // Get the filenames. 483 if (Buf + FilenamesSize > End) 484 return make_error<CoverageMapError>(coveragemap_error::malformed); 485 size_t FilenamesBegin = Filenames.size(); 486 RawCoverageFilenamesReader Reader(StringRef(Buf, FilenamesSize), Filenames); 487 if (auto Err = Reader.read()) 488 return std::move(Err); 489 Buf += FilenamesSize; 490 491 // We'll read the coverage mapping records in the loop below. 492 const char *CovBuf = Buf; 493 Buf += CoverageSize; 494 const char *CovEnd = Buf; 495 496 if (Buf > End) 497 return make_error<CoverageMapError>(coveragemap_error::malformed); 498 // Each coverage map has an alignment of 8, so we need to adjust alignment 499 // before reading the next map. 500 Buf += alignmentAdjustment(Buf, 8); 501 502 auto CFR = reinterpret_cast<const FuncRecordType *>(FunBuf); 503 while ((const char *)CFR < FunEnd) { 504 // Read the function information 505 uint32_t DataSize = CFR->template getDataSize<Endian>(); 506 507 // Now use that to read the coverage data. 508 if (CovBuf + DataSize > CovEnd) 509 return make_error<CoverageMapError>(coveragemap_error::malformed); 510 auto Mapping = StringRef(CovBuf, DataSize); 511 CovBuf += DataSize; 512 513 if (Error Err = 514 insertFunctionRecordIfNeeded(CFR, Mapping, FilenamesBegin)) 515 return std::move(Err); 516 CFR++; 517 } 518 return Buf; 519 } 520 }; 521 522 } // end anonymous namespace 523 524 template <class IntPtrT, support::endianness Endian> 525 Expected<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get( 526 CovMapVersion Version, InstrProfSymtab &P, 527 std::vector<BinaryCoverageReader::ProfileMappingRecord> &R, 528 std::vector<StringRef> &F) { 529 using namespace coverage; 530 531 switch (Version) { 532 case CovMapVersion::Version1: 533 return llvm::make_unique<VersionedCovMapFuncRecordReader< 534 CovMapVersion::Version1, IntPtrT, Endian>>(P, R, F); 535 case CovMapVersion::Version2: 536 case CovMapVersion::Version3: 537 // Decompress the name data. 538 if (Error E = P.create(P.getNameData())) 539 return std::move(E); 540 if (Version == CovMapVersion::Version2) 541 return llvm::make_unique<VersionedCovMapFuncRecordReader< 542 CovMapVersion::Version2, IntPtrT, Endian>>(P, R, F); 543 else 544 return llvm::make_unique<VersionedCovMapFuncRecordReader< 545 CovMapVersion::Version3, IntPtrT, Endian>>(P, R, F); 546 } 547 llvm_unreachable("Unsupported version"); 548 } 549 550 template <typename T, support::endianness Endian> 551 static Error readCoverageMappingData( 552 InstrProfSymtab &ProfileNames, StringRef Data, 553 std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records, 554 std::vector<StringRef> &Filenames) { 555 using namespace coverage; 556 557 // Read the records in the coverage data section. 558 auto CovHeader = 559 reinterpret_cast<const CovMapHeader *>(Data.data()); 560 CovMapVersion Version = (CovMapVersion)CovHeader->getVersion<Endian>(); 561 if (Version > CovMapVersion::CurrentVersion) 562 return make_error<CoverageMapError>(coveragemap_error::unsupported_version); 563 Expected<std::unique_ptr<CovMapFuncRecordReader>> ReaderExpected = 564 CovMapFuncRecordReader::get<T, Endian>(Version, ProfileNames, Records, 565 Filenames); 566 if (Error E = ReaderExpected.takeError()) 567 return E; 568 auto Reader = std::move(ReaderExpected.get()); 569 for (const char *Buf = Data.data(), *End = Buf + Data.size(); Buf < End;) { 570 auto NextHeaderOrErr = Reader->readFunctionRecords(Buf, End); 571 if (auto E = NextHeaderOrErr.takeError()) 572 return E; 573 Buf = NextHeaderOrErr.get(); 574 } 575 return Error::success(); 576 } 577 578 static const char *TestingFormatMagic = "llvmcovmtestdata"; 579 580 static Error loadTestingFormat(StringRef Data, InstrProfSymtab &ProfileNames, 581 StringRef &CoverageMapping, 582 uint8_t &BytesInAddress, 583 support::endianness &Endian) { 584 BytesInAddress = 8; 585 Endian = support::endianness::little; 586 587 Data = Data.substr(StringRef(TestingFormatMagic).size()); 588 if (Data.empty()) 589 return make_error<CoverageMapError>(coveragemap_error::truncated); 590 unsigned N = 0; 591 auto ProfileNamesSize = 592 decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N); 593 if (N > Data.size()) 594 return make_error<CoverageMapError>(coveragemap_error::malformed); 595 Data = Data.substr(N); 596 if (Data.empty()) 597 return make_error<CoverageMapError>(coveragemap_error::truncated); 598 N = 0; 599 uint64_t Address = 600 decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N); 601 if (N > Data.size()) 602 return make_error<CoverageMapError>(coveragemap_error::malformed); 603 Data = Data.substr(N); 604 if (Data.size() < ProfileNamesSize) 605 return make_error<CoverageMapError>(coveragemap_error::malformed); 606 if (Error E = ProfileNames.create(Data.substr(0, ProfileNamesSize), Address)) 607 return E; 608 CoverageMapping = Data.substr(ProfileNamesSize); 609 // Skip the padding bytes because coverage map data has an alignment of 8. 610 if (CoverageMapping.empty()) 611 return make_error<CoverageMapError>(coveragemap_error::truncated); 612 size_t Pad = alignmentAdjustment(CoverageMapping.data(), 8); 613 if (CoverageMapping.size() < Pad) 614 return make_error<CoverageMapError>(coveragemap_error::malformed); 615 CoverageMapping = CoverageMapping.substr(Pad); 616 return Error::success(); 617 } 618 619 static Expected<SectionRef> lookupSection(ObjectFile &OF, StringRef Name) { 620 StringRef FoundName; 621 for (const auto &Section : OF.sections()) { 622 if (auto EC = Section.getName(FoundName)) 623 return errorCodeToError(EC); 624 if (FoundName == Name) 625 return Section; 626 } 627 return make_error<CoverageMapError>(coveragemap_error::no_data_found); 628 } 629 630 static Error loadBinaryFormat(MemoryBufferRef ObjectBuffer, 631 InstrProfSymtab &ProfileNames, 632 StringRef &CoverageMapping, 633 uint8_t &BytesInAddress, 634 support::endianness &Endian, StringRef Arch) { 635 auto BinOrErr = createBinary(ObjectBuffer); 636 if (!BinOrErr) 637 return BinOrErr.takeError(); 638 auto Bin = std::move(BinOrErr.get()); 639 std::unique_ptr<ObjectFile> OF; 640 if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin.get())) { 641 // If we have a universal binary, try to look up the object for the 642 // appropriate architecture. 643 auto ObjectFileOrErr = Universal->getObjectForArch(Arch); 644 if (!ObjectFileOrErr) 645 return ObjectFileOrErr.takeError(); 646 OF = std::move(ObjectFileOrErr.get()); 647 } else if (isa<ObjectFile>(Bin.get())) { 648 // For any other object file, upcast and take ownership. 649 OF.reset(cast<ObjectFile>(Bin.release())); 650 // If we've asked for a particular arch, make sure they match. 651 if (!Arch.empty() && OF->getArch() != Triple(Arch).getArch()) 652 return errorCodeToError(object_error::arch_not_found); 653 } else 654 // We can only handle object files. 655 return make_error<CoverageMapError>(coveragemap_error::malformed); 656 657 // The coverage uses native pointer sizes for the object it's written in. 658 BytesInAddress = OF->getBytesInAddress(); 659 Endian = OF->isLittleEndian() ? support::endianness::little 660 : support::endianness::big; 661 662 // Look for the sections that we are interested in. 663 auto ObjFormat = OF->getTripleObjectFormat(); 664 auto NamesSection = 665 lookupSection(*OF, getInstrProfSectionName(IPSK_name, ObjFormat, 666 /*AddSegmentInfo=*/false)); 667 if (auto E = NamesSection.takeError()) 668 return E; 669 auto CoverageSection = 670 lookupSection(*OF, getInstrProfSectionName(IPSK_covmap, ObjFormat, 671 /*AddSegmentInfo=*/false)); 672 if (auto E = CoverageSection.takeError()) 673 return E; 674 675 // Get the contents of the given sections. 676 if (auto EC = CoverageSection->getContents(CoverageMapping)) 677 return errorCodeToError(EC); 678 if (Error E = ProfileNames.create(*NamesSection)) 679 return E; 680 681 return Error::success(); 682 } 683 684 Expected<std::unique_ptr<BinaryCoverageReader>> 685 BinaryCoverageReader::create(std::unique_ptr<MemoryBuffer> &ObjectBuffer, 686 StringRef Arch) { 687 std::unique_ptr<BinaryCoverageReader> Reader(new BinaryCoverageReader()); 688 689 StringRef Coverage; 690 uint8_t BytesInAddress; 691 support::endianness Endian; 692 Error E = Error::success(); 693 consumeError(std::move(E)); 694 if (ObjectBuffer->getBuffer().startswith(TestingFormatMagic)) 695 // This is a special format used for testing. 696 E = loadTestingFormat(ObjectBuffer->getBuffer(), Reader->ProfileNames, 697 Coverage, BytesInAddress, Endian); 698 else 699 E = loadBinaryFormat(ObjectBuffer->getMemBufferRef(), Reader->ProfileNames, 700 Coverage, BytesInAddress, Endian, Arch); 701 if (E) 702 return std::move(E); 703 704 if (BytesInAddress == 4 && Endian == support::endianness::little) 705 E = readCoverageMappingData<uint32_t, support::endianness::little>( 706 Reader->ProfileNames, Coverage, Reader->MappingRecords, 707 Reader->Filenames); 708 else if (BytesInAddress == 4 && Endian == support::endianness::big) 709 E = readCoverageMappingData<uint32_t, support::endianness::big>( 710 Reader->ProfileNames, Coverage, Reader->MappingRecords, 711 Reader->Filenames); 712 else if (BytesInAddress == 8 && Endian == support::endianness::little) 713 E = readCoverageMappingData<uint64_t, support::endianness::little>( 714 Reader->ProfileNames, Coverage, Reader->MappingRecords, 715 Reader->Filenames); 716 else if (BytesInAddress == 8 && Endian == support::endianness::big) 717 E = readCoverageMappingData<uint64_t, support::endianness::big>( 718 Reader->ProfileNames, Coverage, Reader->MappingRecords, 719 Reader->Filenames); 720 else 721 return make_error<CoverageMapError>(coveragemap_error::malformed); 722 if (E) 723 return std::move(E); 724 return std::move(Reader); 725 } 726 727 Error BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) { 728 if (CurrentRecord >= MappingRecords.size()) 729 return make_error<CoverageMapError>(coveragemap_error::eof); 730 731 FunctionsFilenames.clear(); 732 Expressions.clear(); 733 MappingRegions.clear(); 734 auto &R = MappingRecords[CurrentRecord]; 735 RawCoverageMappingReader Reader( 736 R.CoverageMapping, 737 makeArrayRef(Filenames).slice(R.FilenamesBegin, R.FilenamesSize), 738 FunctionsFilenames, Expressions, MappingRegions); 739 if (auto Err = Reader.read()) 740 return Err; 741 742 Record.FunctionName = R.FunctionName; 743 Record.FunctionHash = R.FunctionHash; 744 Record.Filenames = FunctionsFilenames; 745 Record.Expressions = Expressions; 746 Record.MappingRegions = MappingRegions; 747 748 ++CurrentRecord; 749 return Error::success(); 750 } 751