+ std::copy(S, E, std::inserter(*Ints, Ints->end()));
+}
+
+struct FileLoc {
+ bool operator<(const FileLoc &RHS) const {
+ return std::tie(FileName, Line) < std::tie(RHS.FileName, RHS.Line);
+ }
+
+ std::string FileName;
+ uint32_t Line;
+};
+
+struct FunctionLoc {
+ bool operator<(const FunctionLoc &RHS) const {
+ return std::tie(Loc, FunctionName) < std::tie(RHS.Loc, RHS.FunctionName);
+ }
+
+ FileLoc Loc;
+ std::string FunctionName;
+};
+
+std::string stripPathPrefix(std::string Path) {
+ if (ClStripPathPrefix.empty())
+ return Path;
+ size_t Pos = Path.find(ClStripPathPrefix);
+ if (Pos == std::string::npos)
+ return Path;
+ return Path.substr(Pos + ClStripPathPrefix.size());
+}
+
+// Compute [FileLoc -> FunctionName] map for given addresses.
+static std::map<FileLoc, std::string>
+computeFunctionsMap(const std::set<uint64_t> &Addrs) {
+ std::map<FileLoc, std::string> Fns;
+
+ symbolize::LLVMSymbolizer::Options SymbolizerOptions;
+ SymbolizerOptions.Demangle = ClDemangle;
+ SymbolizerOptions.UseSymbolTable = true;
+ symbolize::LLVMSymbolizer Symbolizer(SymbolizerOptions);
+
+ // Fill in Fns map.
+ for (auto Addr : Addrs) {
+ auto InliningInfo = Symbolizer.symbolizeInlinedCode(ClBinaryName, Addr);
+ FailIfError(InliningInfo);
+ for (uint32_t i = 0; i < InliningInfo->getNumberOfFrames(); ++i) {
+ auto FrameInfo = InliningInfo->getFrame(i);
+ SmallString<256> FileName(FrameInfo.FileName);
+ sys::path::remove_dots(FileName, /* remove_dot_dot */ true);
+ FileLoc Loc = {FileName.str(), FrameInfo.Line};
+ Fns[Loc] = FrameInfo.FunctionName;
+ }
+ }
+
+ return Fns;
+}
+
+// Compute functions for given addresses. It keeps only the first
+// occurence of a function within a file.
+std::set<FunctionLoc> computeFunctionLocs(const std::set<uint64_t> &Addrs) {
+ std::map<FileLoc, std::string> Fns = computeFunctionsMap(Addrs);
+
+ std::set<FunctionLoc> result;
+ std::string LastFileName;
+ std::set<std::string> ProcessedFunctions;
+
+ for (const auto &P : Fns) {
+ std::string FileName = P.first.FileName;
+ std::string FunctionName = P.second;
+
+ if (LastFileName != FileName)
+ ProcessedFunctions.clear();
+ LastFileName = FileName;
+
+ if (!ProcessedFunctions.insert(FunctionName).second)
+ continue;
+
+ result.insert(FunctionLoc{P.first, P.second});
+ }
+
+ return result;
+}
+
+// Locate __sanitizer_cov function address.
+static uint64_t findSanitizerCovFunction(const object::ObjectFile &O) {
+ for (const object::SymbolRef &Symbol : O.symbols()) {
+ ErrorOr<uint64_t> AddressOrErr = Symbol.getAddress();
+ FailIfError(AddressOrErr);
+
+ ErrorOr<StringRef> Name = Symbol.getName();
+ FailIfError(Name);
+
+ if (Name.get() == "__sanitizer_cov") {
+ return AddressOrErr.get();
+ }
+ }
+ FailIfNotEmpty("__sanitizer_cov not found");
+ return 0; // not reachable.
+}
+
+// Locate addresses of all coverage points in a file. Coverage point
+// is defined as the 'address of instruction following __sanitizer_cov
+// call - 1'.
+static void getObjectCoveragePoints(const object::ObjectFile &O,
+ std::set<uint64_t> *Addrs) {
+ Triple TheTriple("unknown-unknown-unknown");
+ TheTriple.setArch(Triple::ArchType(O.getArch()));
+ auto TripleName = TheTriple.getTriple();
+
+ std::string Error;
+ const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
+ FailIfNotEmpty(Error);
+
+ std::unique_ptr<const MCSubtargetInfo> STI(
+ TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+ FailIfEmpty(STI, "no subtarget info for target " + TripleName);
+
+ std::unique_ptr<const MCRegisterInfo> MRI(
+ TheTarget->createMCRegInfo(TripleName));
+ FailIfEmpty(MRI, "no register info for target " + TripleName);
+
+ std::unique_ptr<const MCAsmInfo> AsmInfo(
+ TheTarget->createMCAsmInfo(*MRI, TripleName));
+ FailIfEmpty(AsmInfo, "no asm info for target " + TripleName);
+
+ std::unique_ptr<const MCObjectFileInfo> MOFI(new MCObjectFileInfo);
+ MCContext Ctx(AsmInfo.get(), MRI.get(), MOFI.get());
+ std::unique_ptr<MCDisassembler> DisAsm(
+ TheTarget->createMCDisassembler(*STI, Ctx));
+ FailIfEmpty(DisAsm, "no disassembler info for target " + TripleName);
+
+ std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
+ FailIfEmpty(MII, "no instruction info for target " + TripleName);
+
+ std::unique_ptr<const MCInstrAnalysis> MIA(
+ TheTarget->createMCInstrAnalysis(MII.get()));
+ FailIfEmpty(MIA, "no instruction analysis info for target " + TripleName);
+
+ uint64_t SanCovAddr = findSanitizerCovFunction(O);
+
+ for (const auto Section : O.sections()) {
+ if (Section.isVirtual() || !Section.isText()) // llvm-objdump does the same.
+ continue;
+ uint64_t SectionAddr = Section.getAddress();
+ uint64_t SectSize = Section.getSize();
+ if (!SectSize)
+ continue;
+
+ StringRef SectionName;
+ FailIfError(Section.getName(SectionName));
+
+ StringRef BytesStr;
+ FailIfError(Section.getContents(BytesStr));
+ ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()),
+ BytesStr.size());
+
+ for (uint64_t Index = 0, Size = 0; Index < Section.getSize();
+ Index += Size) {
+ MCInst Inst;
+ if (!DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
+ SectionAddr + Index, nulls(), nulls())) {
+ if (Size == 0)
+ Size = 1;
+ continue;
+ }
+ uint64_t Target;
+ if (MIA->isCall(Inst) &&
+ MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target)) {
+ if (Target == SanCovAddr) {
+ // Sanitizer coverage uses the address of the next instruction - 1.
+ Addrs->insert(Index + SectionAddr + Size - 1);
+ }
+ }
+ }
+ }