This is an archive of the discontinued LLVM Phabricator instance.

Differential D136385

Add support for MC/DC in LLVM Source-Based Code Coverage
Needs ReviewPublic

Authored by alanphipps on Oct 20 2022, 3:15 PM.

Details

Reviewers
vsk
phosek
Summary

I previously upstreamed work to enable Branch Coverage (https://reviews.llvm.org/D84467), which was pushed in early 2021. MC/DC (Modified Condition/Decision Coverage) is a planned enhancement to Source-based Code Coverage. Implementation was completed in May for our downstream Arm compiler, and in general use it has not yielded any issues. Our downstream implementation does not use most of the compiler-rt profile functionality, and so that is relatively new to this patch.

See attached file for Background, Motivation, Design, and Implementation Concepts:

mcdc-design-doc.pdf316 KBDownload

I am also available at Discord @alanphipps

Recommended order for the review. Start with the front-end changes:

  • New Option and common parameters
    • CodeGenOptions.def
    • Options.td
    • Clang.cpp
  • Bitmask Coverage Object Allocation:
    • CodeGenPGO.h, CodeGenPGO.cpp
  • Source Region Mapping:
    • CoverageMappingGen.h, CoverageMappingGen.cpp
  • Instrumentation (during IR lowering):
    • CGExprScalar.cpp
    • CGStmt.cpp
    • CodeGenFunction.h, CodeGenFunction.cpp

LLVM back-end processing and profile reading/writing:

  • Instrumentation intrinsic lowering and section allocation:
    • IntrinsicInst.h
    • Intrinsics.td
    • IntrinsicInst.cpp
    • InstrProfiling.h, InstrProfiling.cpp
  • Profiling format read/write:
    • CoverageMappingWriter.cpp
    • CoverageMappingReader.cpp
  • Profile read/write:
    • InstrProf.h, InstrProf.cpp
    • InstrProfWriter.h, InstrProfWriter.cpp
    • InstrProfReader.h, InstrProfReader.cpp
  • Runtime profiling aids:
    • InstrProfiling.h
    • InstrProfilingFilebaremetal.c
    • InstrProfilingPlatformBaremetal.c
    • compiler-rt

Visualization and Evaluation:

  • Bitmask evaluation and MC/DC Region Analysis:
    • CoverageMapping.h, CoverageMapping.cpp
  • Creation of MC/DC Views with Records:
    • CodeCoverage.cpp
    • CoverageViewOptions.h
  • Text, HTML Visualization:
    • SourceCoverageView.h, SourceCoverageView.cpp
    • SourceCoverageViewHTML.h, SourceCoverageViewHTML.cpp
    • SourceCoverageViewText.h, SourceCoverageViewText.cpp
  • Summary Report Generation:
    • CoverageSummaryInfo.h, CoverageSummaryInfo.cpp
    • CoverageReport.cpp
  • JSON exporting:
    • CoverageExporterJson.cpp

This patch has been tested on windows (stage1) and linux/mac (stage1 and stage2)

Unsupported at the moment (please consider enabling in a future patch!):

  • Fuchsia
  • Debug Correlation

Diff Detail

Event Timeline

alanphipps created this revision.Oct 20 2022, 3:15 PM
Herald added a project: Restricted Project. · View Herald TranscriptOct 20 2022, 3:15 PM
Herald added subscribers: Enna1, wenlei, hiraditya. · View Herald Transcript
alanphipps requested review of this revision.Oct 20 2022, 3:15 PM
Herald added projects: Restricted Project, Restricted Project, Restricted Project. · View Herald TranscriptOct 20 2022, 3:15 PM
Herald added subscribers: llvm-commits, Restricted Project, cfe-commits and 2 others. · View Herald Transcript
Harbormaster completed remote builds in B193341: Diff 469371.Oct 20 2022, 3:16 PM
alanphipps edited the summary of this revision. (Show Details)Oct 20 2022, 3:23 PM
Herald added subscribers: abidh, kristof.beyls. · View Herald TranscriptOct 20 2022, 3:23 PM
alanphipps edited the summary of this revision. (Show Details)Oct 20 2022, 3:27 PM
alanphipps edited the summary of this revision. (Show Details)Oct 21 2022, 1:13 PM
alanphipps added reviewers: vsk, phosek.Oct 21 2022, 1:32 PM
alanphipps added a subscriber: peter.smith.
ellis added a subscriber: ellis.Oct 24 2022, 4:48 PM
ellis added inline comments.
llvm/lib/ProfileData/InstrProfCorrelator.cpp
208

Since BitmaskOffset and NumBitmaskBytes are always zero, I would rather set them as zero here rather than passing in more parameters. See ValuesPtr.

peter.smith added a comment.Oct 28 2022, 2:55 AM

I've got about as far as the clang changes. As I mentioned in Discourse I'm not familiar enough in this area to give good feedback on the implementation, most if not all my comments fall under the bike shedding category. Will need to leave the high-level feedback to people that are more experienced in this area.

Thanks very much for uploading the design doc pdf, that was very useful. Although likely not for this patch as it is large enough already, will be worth updating https://llvm.org/docs/CoverageMappingFormat.html and https://clang.llvm.org/docs/SourceBasedCodeCoverage.html

I suspect that this patch will need to get split up into smaller parts. While it is very useful to see everything at once, it may be better to use this as a kind of support for the RFC, and then split off the implementation into smaller independently reviewable parts, even if the full functionality isn't useable until the last patch lands. For example the LLVM changes could be looked at and accepted prior to clang.

Will try and look and some more parts next week, my apologies I can't go through it all at once.

clang/lib/CodeGen/CodeGenFunction.h
1522

Would MCDCTrackingStateAddr be more appropriate? It could save people some time tracking back up to the comment to work out what Temp is being used for.

1542

Can this be bool isMCDCCoverageEnabled() const

1554

Is the return necessary here?

1558

This looks like it doesn't need to be a member function? I can appreciate that here may be the most convenient place to put it though.

clang/lib/CodeGen/CodeGenPGO.cpp
164

perhaps worth including index in the name, for example NextBitmaskIdx . Will help prevent confusion as to whether this is an index or an actual bitmask (comment does say, but harder to see from reading the code).

979

unsigned MCDCMaxConditions = (CGM.getCodeGenOpts().MCDCCoverage) ? CGM.getCodeGenOpts().MCDCMaxConditionCount : 0;

Purely subjective opinion on my part though.

clang/lib/CodeGen/CoverageMappingGen.cpp
102

Worth a comment that these are associated with MCDC?

662

Could this be a free function? If not then could it be const?

718

Would it be better to invert the condition and early exit? This would save a level of indentation for the rest of the function.

759

Would it be better to invert the condition and early exit? This would save a level of indentation for the rest of the function.

clang/lib/Driver/ToolChains/Clang.cpp
924

Maybe able to simplify this to if (Args.hasFlag(options::OPT_fcoverage_mapping) and remove CoverageMapping. I think that in the case of !ProfileGenerateArg there are several options so it needed to be a variable.

alanphipps added a comment.Oct 28 2022, 9:24 AM

Thank you (both) for looking at it! I appreciate your time.

In D136385#3891311, @peter.smith wrote:

I suspect that this patch will need to get split up into smaller parts. While it is very useful to see everything at once, it may be better to use this as a kind of support for the RFC, and then split off the implementation into smaller independently reviewable parts, even if the full functionality isn't useable until the last patch lands. For example the LLVM changes could be looked at and accepted prior to clang.

I agree -- I will explore splitting the review up, probably next week. And I'll review the suggested adjustments.

alanphipps edited the summary of this revision. (Show Details)Oct 28 2022, 9:25 AM
alanphipps added a comment.Nov 28 2022, 12:24 PM

Thank you for the comments thus-far. I have split this patch into three stacked patches and updated them according to comments found on this review:

Clang Front-end: https://reviews.llvm.org/D138849
LLVM back-end/compiler-rt: https://reviews.llvm.org/D138846
llvm-cov visualization/evaluation: https://reviews.llvm.org/D138847

ErikCato added a subscriber: ErikCato.Dec 11 2022, 3:20 AM
chapuni added a subscriber: chapuni.Jan 17 2023, 9:08 PM
flip1995 added a subscriber: flip1995.Jun 2 2023, 2:46 AM
Herald added subscribers: hoy, wlei. · View Herald TranscriptJun 2 2023, 2:46 AM

Revision Contents

PathSize
clang/
include/
clang/
Basic/
2 lines
Driver/
4 lines
lib/
CodeGen/
55 lines
14 lines
55 lines
68 lines
13 lines
247 lines
12 lines
392 lines
Driver/
ToolChains/
12 lines
4 lines
test/
CoverageMapping/
33 lines
1 line
1 line
1 line
10 lines
7 lines
10 lines
108 lines
131 lines
110 lines
Driver/
2 lines
Profile/
4 lines
68 lines
85 lines
compiler-rt/
include/
profile/
20 lines
lib/
profile/
22 lines
4 lines
43 lines
51 lines
7 lines
32 lines
9 lines
12 lines
4 lines
7 lines
18 lines
test/
profile/
ContinuousSyncMode/
26 lines
9 lines
llvm/
include/
llvm/
IR/
56 lines
15 lines
ProfileData/
Coverage/
232 lines
23 lines
3 lines
20 lines
9 lines
Transforms/
Instrumentation/
33 lines
lib/
CodeGen/
SelectionDAG/
4 lines
IR/
4 lines
ProfileData/
Coverage/
277 lines
33 lines
17 lines
27 lines
15 lines
110 lines
18 lines
Transforms/
Instrumentation/
371 lines
test/
Transforms/
PGOProfile/
4 lines
tools/
llvm-cov/
Inputs/
6 lines
117 lines
400 lines
27 lines
32 lines
44 lines
36 lines
44 lines
203 lines
8 lines
72 lines
138 lines
llvm-profdata/
Inputs/
16 lines
35 lines
23 lines
23 lines
23 lines
23 lines
11 lines
3 lines
7 lines
8 lines
7 lines
54 lines
26 lines
26 lines
22 lines
22 lines
10 lines
tools/
llvm-cov/
56 lines
44 lines
47 lines
50 lines
19 lines
2 lines
28 lines
14 lines
3 lines
52 lines
3 lines
51 lines
unittests/
ProfileData/
44 lines

Diff 469371

clang/include/clang/Basic/CodeGenOptions.def

Show First 20 Lines • Show All 216 Lines • ▼ Show 20 Lines
/// Partition functions into N groups and select only functions in group i to be /// Partition functions into N groups and select only functions in group i to be
/// instrumented. Selected group numbers can be 0 to N-1 inclusive. /// instrumented. Selected group numbers can be 0 to N-1 inclusive.
VALUE_CODEGENOPT(ProfileTotalFunctionGroups, 32, 1) VALUE_CODEGENOPT(ProfileTotalFunctionGroups, 32, 1)
VALUE_CODEGENOPT(ProfileSelectedFunctionGroup, 32, 0) VALUE_CODEGENOPT(ProfileSelectedFunctionGroup, 32, 0)
CODEGENOPT(CoverageMapping , 1, 0) ///< Generate coverage mapping regions to CODEGENOPT(CoverageMapping , 1, 0) ///< Generate coverage mapping regions to
///< enable code coverage analysis. ///< enable code coverage analysis.
CODEGENOPT(DumpCoverageMapping , 1, 0) ///< Dump the generated coverage mapping CODEGENOPT(DumpCoverageMapping , 1, 0) ///< Dump the generated coverage mapping
///< regions. ///< regions.
CODEGENOPT(MCDCCoverage , 1, 0) ///< Enable MC/DC code coverage criteria.
CODEGENOPT(MCDCMaxConditionCount , 8, 6) ///< MC/DC Maximum Condition Count.
/// If -fpcc-struct-return or -freg-struct-return is specified. /// If -fpcc-struct-return or -freg-struct-return is specified.
ENUM_CODEGENOPT(StructReturnConvention, StructReturnConventionKind, 2, SRCK_Default) ENUM_CODEGENOPT(StructReturnConvention, StructReturnConventionKind, 2, SRCK_Default)
CODEGENOPT(RelaxAll , 1, 0) ///< Relax all machine code instructions. CODEGENOPT(RelaxAll , 1, 0) ///< Relax all machine code instructions.
CODEGENOPT(RelaxedAliasing , 1, 0) ///< Set when -fno-strict-aliasing is enabled. CODEGENOPT(RelaxedAliasing , 1, 0) ///< Set when -fno-strict-aliasing is enabled.
CODEGENOPT(StructPathTBAA , 1, 0) ///< Whether or not to use struct-path TBAA. CODEGENOPT(StructPathTBAA , 1, 0) ///< Whether or not to use struct-path TBAA.
CODEGENOPT(NewStructPathTBAA , 1, 0) ///< Whether or not to use enhanced struct-path TBAA. CODEGENOPT(NewStructPathTBAA , 1, 0) ///< Whether or not to use enhanced struct-path TBAA.
▲ Show 20 Lines • Show All 269 Lines • Show Last 20 Lines

clang/include/clang/Driver/Options.td

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,291 Lines • ▼ Show 20 Lines
def fprofile_remapping_file_EQ : Joined<["-"], "fprofile-remapping-file=">, def fprofile_remapping_file_EQ : Joined<["-"], "fprofile-remapping-file=">,
Group<f_Group>, Flags<[CC1Option, CoreOption]>, MetaVarName<"<file>">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, MetaVarName<"<file>">,
HelpText<"Use the remappings described in <file> to match the profile data against names in the program">, HelpText<"Use the remappings described in <file> to match the profile data against names in the program">,
MarshallingInfoString<CodeGenOpts<"ProfileRemappingFile">>; MarshallingInfoString<CodeGenOpts<"ProfileRemappingFile">>;
defm coverage_mapping : BoolFOption<"coverage-mapping", defm coverage_mapping : BoolFOption<"coverage-mapping",
CodeGenOpts<"CoverageMapping">, DefaultFalse, CodeGenOpts<"CoverageMapping">, DefaultFalse,
PosFlag<SetTrue, [CC1Option], "Generate coverage mapping to enable code coverage analysis">, PosFlag<SetTrue, [CC1Option], "Generate coverage mapping to enable code coverage analysis">,
NegFlag<SetFalse, [], "Disable code coverage analysis">, BothFlags<[CoreOption]>>; NegFlag<SetFalse, [], "Disable code coverage analysis">, BothFlags<[CoreOption]>>;
defm mcdc_coverage : BoolFOption<"mcdc",
CodeGenOpts<"MCDCCoverage">, DefaultFalse,
PosFlag<SetTrue, [CC1Option], "Enable MC/DC criteria when generating code coverage">,
NegFlag<SetFalse, [], "Disable MC/DC coverage criteria">, BothFlags<[CoreOption]>>;
def fprofile_generate : Flag<["-"], "fprofile-generate">, def fprofile_generate : Flag<["-"], "fprofile-generate">,
Group<f_Group>, Flags<[CoreOption]>, Group<f_Group>, Flags<[CoreOption]>,
HelpText<"Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">; HelpText<"Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
def fprofile_generate_EQ : Joined<["-"], "fprofile-generate=">, def fprofile_generate_EQ : Joined<["-"], "fprofile-generate=">,
Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<directory>">, Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<directory>">,
HelpText<"Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)">; HelpText<"Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
def fcs_profile_generate : Flag<["-"], "fcs-profile-generate">, def fcs_profile_generate : Flag<["-"], "fcs-profile-generate">,
Group<f_Group>, Flags<[CoreOption]>, Group<f_Group>, Flags<[CoreOption]>,
▲ Show 20 Lines • Show All 5,688 Lines • Show Last 20 Lines

clang/lib/CodeGen/CGExprScalar.cpp

Show First 20 Lines • Show All 4,513 Lines • ▼ Show 20 LinesValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
// If we have 0 && RHS, see if we can elide RHS, if so, just return 0. // If we have 0 && RHS, see if we can elide RHS, if so, just return 0.
// If we have 1 && X, just emit X without inserting the control flow. // If we have 1 && X, just emit X without inserting the control flow.
bool LHSCondVal; bool LHSCondVal;
if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) { if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
if (LHSCondVal) { // If we have 1 && X, just emit X. if (LHSCondVal) { // If we have 1 && X, just emit X.
CGF.incrementProfileCounter(E); CGF.incrementProfileCounter(E);
// If the top of the logical operator nest, reset the MCDC temp to 0.
if (CGF.MCDCLogOpStack.empty())
CGF.resetMCDCTempValue(E);
CGF.MCDCLogOpStack.push_back(E);
Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
// If we're generating for profiling or coverage, generate a branch to a // If we're generating for profiling or coverage, generate a branch to a
// block that increments the RHS counter needed to track branch condition // block that increments the RHS counter needed to track branch condition
// coverage. In this case, use "FBlock" as both the final "TrueBlock" and // coverage. In this case, use "FBlock" as both the final "TrueBlock" and
// "FalseBlock" after the increment is done. // "FalseBlock" after the increment is done.
if (InstrumentRegions && if (InstrumentRegions &&
CodeGenFunction::isInstrumentedCondition(E->getRHS())) { CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
CGF.updateMCDCTempValue(E->getRHS(), RHSCond);
llvm::BasicBlock *FBlock = CGF.createBasicBlock("land.end"); llvm::BasicBlock *FBlock = CGF.createBasicBlock("land.end");
llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("land.rhscnt"); llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("land.rhscnt");
Builder.CreateCondBr(RHSCond, RHSBlockCnt, FBlock); Builder.CreateCondBr(RHSCond, RHSBlockCnt, FBlock);
CGF.EmitBlock(RHSBlockCnt); CGF.EmitBlock(RHSBlockCnt);
CGF.incrementProfileCounter(E->getRHS()); CGF.incrementProfileCounter(E->getRHS());
CGF.EmitBranch(FBlock); CGF.EmitBranch(FBlock);
CGF.EmitBlock(FBlock); CGF.EmitBlock(FBlock);
} }
CGF.MCDCLogOpStack.pop_back();
// If the top of the logical operator nest, update the MCDC bitmask.
if (CGF.MCDCLogOpStack.empty())
CGF.updateMCDCBitmask(E);
// ZExt result to int or bool. // ZExt result to int or bool.
return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext");
} }
// 0 && RHS: If it is safe, just elide the RHS, and return 0/false. // 0 && RHS: If it is safe, just elide the RHS, and return 0/false.
if (!CGF.ContainsLabel(E->getRHS())) if (!CGF.ContainsLabel(E->getRHS()))
return llvm::Constant::getNullValue(ResTy); return llvm::Constant::getNullValue(ResTy);
} }
// If the top of the logical operator nest, reset the MCDC temp to 0.
if (CGF.MCDCLogOpStack.empty())
CGF.resetMCDCTempValue(E);
CGF.MCDCLogOpStack.push_back(E);
llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end");
llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs");
CodeGenFunction::ConditionalEvaluation eval(CGF); CodeGenFunction::ConditionalEvaluation eval(CGF);
// Branch on the LHS first. If it is false, go to the failure (cont) block. // Branch on the LHS first. If it is false, go to the failure (cont) block.
CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock, CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock,
CGF.getProfileCount(E->getRHS())); CGF.getProfileCount(E->getRHS()));
Show All 16 LinesValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
// Reaquire the RHS block, as there may be subblocks inserted. // Reaquire the RHS block, as there may be subblocks inserted.
RHSBlock = Builder.GetInsertBlock(); RHSBlock = Builder.GetInsertBlock();
// If we're generating for profiling or coverage, generate a branch on the // If we're generating for profiling or coverage, generate a branch on the
// RHS to a block that increments the RHS true counter needed to track branch // RHS to a block that increments the RHS true counter needed to track branch
// condition coverage. // condition coverage.
if (InstrumentRegions && if (InstrumentRegions &&
CodeGenFunction::isInstrumentedCondition(E->getRHS())) { CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
CGF.updateMCDCTempValue(E->getRHS(), RHSCond);
llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("land.rhscnt"); llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("land.rhscnt");
Builder.CreateCondBr(RHSCond, RHSBlockCnt, ContBlock); Builder.CreateCondBr(RHSCond, RHSBlockCnt, ContBlock);
CGF.EmitBlock(RHSBlockCnt); CGF.EmitBlock(RHSBlockCnt);
CGF.incrementProfileCounter(E->getRHS()); CGF.incrementProfileCounter(E->getRHS());
CGF.EmitBranch(ContBlock); CGF.EmitBranch(ContBlock);
PN->addIncoming(RHSCond, RHSBlockCnt); PN->addIncoming(RHSCond, RHSBlockCnt);
} }
// Emit an unconditional branch from this block to ContBlock. // Emit an unconditional branch from this block to ContBlock.
{ {
// There is no need to emit line number for unconditional branch. // There is no need to emit line number for unconditional branch.
auto NL = ApplyDebugLocation::CreateEmpty(CGF); auto NL = ApplyDebugLocation::CreateEmpty(CGF);
CGF.EmitBlock(ContBlock); CGF.EmitBlock(ContBlock);
} }
// Insert an entry into the phi node for the edge with the value of RHSCond. // Insert an entry into the phi node for the edge with the value of RHSCond.
PN->addIncoming(RHSCond, RHSBlock); PN->addIncoming(RHSCond, RHSBlock);
CGF.MCDCLogOpStack.pop_back();
// If the top of the logical operator nest, update the MCDC bitmask.
if (CGF.MCDCLogOpStack.empty())
CGF.updateMCDCBitmask(E);
// Artificial location to preserve the scope information // Artificial location to preserve the scope information
{ {
auto NL = ApplyDebugLocation::CreateArtificial(CGF); auto NL = ApplyDebugLocation::CreateArtificial(CGF);
PN->setDebugLoc(Builder.getCurrentDebugLocation()); PN->setDebugLoc(Builder.getCurrentDebugLocation());
} }
// ZExt result to int. // ZExt result to int.
return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext");
Show All 25 LinesValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
// If we have 1 || RHS, see if we can elide RHS, if so, just return 1. // If we have 1 || RHS, see if we can elide RHS, if so, just return 1.
// If we have 0 || X, just emit X without inserting the control flow. // If we have 0 || X, just emit X without inserting the control flow.
bool LHSCondVal; bool LHSCondVal;
if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) { if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
if (!LHSCondVal) { // If we have 0 || X, just emit X. if (!LHSCondVal) { // If we have 0 || X, just emit X.
CGF.incrementProfileCounter(E); CGF.incrementProfileCounter(E);
// If the top of the logical operator nest, reset the MCDC temp to 0.
if (CGF.MCDCLogOpStack.empty())
CGF.resetMCDCTempValue(E);
CGF.MCDCLogOpStack.push_back(E);
Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
// If we're generating for profiling or coverage, generate a branch to a // If we're generating for profiling or coverage, generate a branch to a
// block that increments the RHS counter need to track branch condition // block that increments the RHS counter need to track branch condition
// coverage. In this case, use "FBlock" as both the final "TrueBlock" and // coverage. In this case, use "FBlock" as both the final "TrueBlock" and
// "FalseBlock" after the increment is done. // "FalseBlock" after the increment is done.
if (InstrumentRegions && if (InstrumentRegions &&
CodeGenFunction::isInstrumentedCondition(E->getRHS())) { CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
CGF.updateMCDCTempValue(E->getRHS(), RHSCond);
llvm::BasicBlock *FBlock = CGF.createBasicBlock("lor.end"); llvm::BasicBlock *FBlock = CGF.createBasicBlock("lor.end");
llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("lor.rhscnt"); llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("lor.rhscnt");
Builder.CreateCondBr(RHSCond, FBlock, RHSBlockCnt); Builder.CreateCondBr(RHSCond, FBlock, RHSBlockCnt);
CGF.EmitBlock(RHSBlockCnt); CGF.EmitBlock(RHSBlockCnt);
CGF.incrementProfileCounter(E->getRHS()); CGF.incrementProfileCounter(E->getRHS());
CGF.EmitBranch(FBlock); CGF.EmitBranch(FBlock);
CGF.EmitBlock(FBlock); CGF.EmitBlock(FBlock);
} }
CGF.MCDCLogOpStack.pop_back();
// If the top of the logical operator nest, update the MCDC bitmask.
if (CGF.MCDCLogOpStack.empty())
CGF.updateMCDCBitmask(E);
// ZExt result to int or bool. // ZExt result to int or bool.
return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext");
} }
// 1 || RHS: If it is safe, just elide the RHS, and return 1/true. // 1 || RHS: If it is safe, just elide the RHS, and return 1/true.
if (!CGF.ContainsLabel(E->getRHS())) if (!CGF.ContainsLabel(E->getRHS()))
return llvm::ConstantInt::get(ResTy, 1); return llvm::ConstantInt::get(ResTy, 1);
} }
// If the top of the logical operator nest, reset the MCDC temp to 0.
if (CGF.MCDCLogOpStack.empty())
CGF.resetMCDCTempValue(E);
CGF.MCDCLogOpStack.push_back(E);
llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end");
llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs");
CodeGenFunction::ConditionalEvaluation eval(CGF); CodeGenFunction::ConditionalEvaluation eval(CGF);
// Branch on the LHS first. If it is true, go to the success (cont) block. // Branch on the LHS first. If it is true, go to the success (cont) block.
CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock, CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock,
CGF.getCurrentProfileCount() - CGF.getCurrentProfileCount() -
Show All 20 LinesValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
// Reaquire the RHS block, as there may be subblocks inserted. // Reaquire the RHS block, as there may be subblocks inserted.
RHSBlock = Builder.GetInsertBlock(); RHSBlock = Builder.GetInsertBlock();
// If we're generating for profiling or coverage, generate a branch on the // If we're generating for profiling or coverage, generate a branch on the
// RHS to a block that increments the RHS true counter needed to track branch // RHS to a block that increments the RHS true counter needed to track branch
// condition coverage. // condition coverage.
if (InstrumentRegions && if (InstrumentRegions &&
CodeGenFunction::isInstrumentedCondition(E->getRHS())) { CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
CGF.updateMCDCTempValue(E->getRHS(), RHSCond);
llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("lor.rhscnt"); llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("lor.rhscnt");
Builder.CreateCondBr(RHSCond, ContBlock, RHSBlockCnt); Builder.CreateCondBr(RHSCond, ContBlock, RHSBlockCnt);
CGF.EmitBlock(RHSBlockCnt); CGF.EmitBlock(RHSBlockCnt);
CGF.incrementProfileCounter(E->getRHS()); CGF.incrementProfileCounter(E->getRHS());
CGF.EmitBranch(ContBlock); CGF.EmitBranch(ContBlock);
PN->addIncoming(RHSCond, RHSBlockCnt); PN->addIncoming(RHSCond, RHSBlockCnt);
} }
// Emit an unconditional branch from this block to ContBlock. Insert an entry // Emit an unconditional branch from this block to ContBlock. Insert an entry
// into the phi node for the edge with the value of RHSCond. // into the phi node for the edge with the value of RHSCond.
CGF.EmitBlock(ContBlock); CGF.EmitBlock(ContBlock);
PN->addIncoming(RHSCond, RHSBlock); PN->addIncoming(RHSCond, RHSBlock);
CGF.MCDCLogOpStack.pop_back();
// If the top of the logical operator nest, update the MCDC bitmask.
if (CGF.MCDCLogOpStack.empty())
CGF.updateMCDCBitmask(E);
// ZExt result to int. // ZExt result to int.
return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext");
} }
Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) {
CGF.EmitIgnoredExpr(E->getLHS()); CGF.EmitIgnoredExpr(E->getLHS());
CGF.EnsureInsertPoint(); CGF.EnsureInsertPoint();
return Visit(E->getRHS()); return Visit(E->getRHS());
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines if (isCheapEnoughToEvaluateUnconditionally(lhsExpr, CGF) &&
if (!LHS) { if (!LHS) {
// If the conditional has void type, make sure we return a null Value*. // If the conditional has void type, make sure we return a null Value*.
assert(!RHS && "LHS and RHS types must match"); assert(!RHS && "LHS and RHS types must match");
return nullptr; return nullptr;
} }
return Builder.CreateSelect(CondV, LHS, RHS, "cond"); return Builder.CreateSelect(CondV, LHS, RHS, "cond");
} }
// If the top of the logical operator nest, reset the MCDC temp to 0.
if (CGF.MCDCLogOpStack.empty())
CGF.resetMCDCTempValue(condExpr);
llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
CodeGenFunction::ConditionalEvaluation eval(CGF); CodeGenFunction::ConditionalEvaluation eval(CGF);
CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock, CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock,
CGF.getProfileCount(lhsExpr)); CGF.getProfileCount(lhsExpr));
Show All 19 Lines if (!LHS)
return RHS; return RHS;
if (!RHS) if (!RHS)
return LHS; return LHS;
// Create a PHI node for the real part. // Create a PHI node for the real part.
llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond"); llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond");
PN->addIncoming(LHS, LHSBlock); PN->addIncoming(LHS, LHSBlock);
PN->addIncoming(RHS, RHSBlock); PN->addIncoming(RHS, RHSBlock);
// If the top of the logical operator nest, update the MCDC bitmask.
if (CGF.MCDCLogOpStack.empty())
CGF.updateMCDCBitmask(condExpr);
return PN; return PN;
} }
Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) {
return Visit(E->getChosenSubExpr()); return Visit(E->getChosenSubExpr());
} }
Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
▲ Show 20 Lines • Show All 484 Lines • Show Last 20 Lines

clang/lib/CodeGen/CGStmt.cpp

Show First 20 Lines • Show All 822 Lines • ▼ Show 20 Linesvoid CodeGenFunction::EmitIfStmt(const IfStmt &S) {
// beneficial. // beneficial.
// As an approximation, preserve the attribute only if both the branch and the // As an approximation, preserve the attribute only if both the branch and the
// parent context were not executed. // parent context were not executed.
Stmt::Likelihood LH = Stmt::LH_None; Stmt::Likelihood LH = Stmt::LH_None;
uint64_t ThenCount = getProfileCount(S.getThen()); uint64_t ThenCount = getProfileCount(S.getThen());
if (!ThenCount && !getCurrentProfileCount() && if (!ThenCount && !getCurrentProfileCount() &&
CGM.getCodeGenOpts().OptimizationLevel) CGM.getCodeGenOpts().OptimizationLevel)
LH = Stmt::getLikelihood(S.getThen(), S.getElse()); LH = Stmt::getLikelihood(S.getThen(), S.getElse());
// When measuring MC/DC, always fully evaluate the condition up front using
// EvaluateExprAsBool() so that the coverage bitmask can be updated prior to
// executing the body of the if.then or if.else. This is useful for when
// there is a 'return' within the body, but this is particularly beneficial
// when one if-stmt is nested within another if-stmt so that all of the MC/DC
// updates are kept linear and consistent.
if (!CGM.getCodeGenOpts().MCDCCoverage)
EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock, ThenCount, LH); EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock, ThenCount, LH);
else {
llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
Builder.CreateCondBr(BoolCondVal, ThenBlock, ElseBlock);
}
// Emit the 'then' code. // Emit the 'then' code.
EmitBlock(ThenBlock); EmitBlock(ThenBlock);
incrementProfileCounter(&S); incrementProfileCounter(&S);
{ {
RunCleanupsScope ThenScope(*this); RunCleanupsScope ThenScope(*this);
EmitStmt(S.getThen()); EmitStmt(S.getThen());
} }
▲ Show 20 Lines • Show All 2,079 Lines • Show Last 20 Lines

clang/lib/CodeGen/CodeGenFunction.h

Show First 20 Lines • Show All 280 Lines • ▼ Show 20 Linespublic:
/// OMPEmitOMPCanonicalLoop called by it will add its CanonicalLoopInfo to /// OMPEmitOMPCanonicalLoop called by it will add its CanonicalLoopInfo to
/// this stack when done. Entering a new loop requires clearing this list; it /// this stack when done. Entering a new loop requires clearing this list; it
/// either means we start parsing a new loop nest (in which case the previous /// either means we start parsing a new loop nest (in which case the previous
/// loop nest goes out of scope) or a second loop in the same level in which /// loop nest goes out of scope) or a second loop in the same level in which
/// case it would be ambiguous into which of the two (or more) loops the loop /// case it would be ambiguous into which of the two (or more) loops the loop
/// nest would extend. /// nest would extend.
SmallVector<llvm::CanonicalLoopInfo *, 4> OMPLoopNestStack; SmallVector<llvm::CanonicalLoopInfo *, 4> OMPLoopNestStack;
/// Stack to track the Logical Operator recursion nest for MC/DC.
SmallVector<const BinaryOperator *, 16> MCDCLogOpStack;
/// Number of nested loop to be consumed by the last surrounding /// Number of nested loop to be consumed by the last surrounding
/// loop-associated directive. /// loop-associated directive.
int ExpectedOMPLoopDepth = 0; int ExpectedOMPLoopDepth = 0;
// CodeGen lambda for loops and support for ordered clause // CodeGen lambda for loops and support for ordered clause
typedef llvm::function_ref<void(CodeGenFunction &, const OMPLoopDirective &, typedef llvm::function_ref<void(CodeGenFunction &, const OMPLoopDirective &,
JumpDest)> JumpDest)>
CodeGenLoopTy; CodeGenLoopTy;
▲ Show 20 Lines • Show All 1,213 Lines • ▼ Show 20 Linesprivate:
OpenMPCancelExitStack OMPCancelStack; OpenMPCancelExitStack OMPCancelStack;
/// Lower the Likelihood knowledge about the \p Cond via llvm.expect intrin. /// Lower the Likelihood knowledge about the \p Cond via llvm.expect intrin.
llvm::Value *emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond, llvm::Value *emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond,
Stmt::Likelihood LH); Stmt::Likelihood LH);
CodeGenPGO PGO; CodeGenPGO PGO;
/// Used by MC/DC to track the execution state of a boolean expression.
Address MCDCTempAddr = Address::invalid();
peter.smithUnsubmitted
Not Done
ReplyInline Actions

Would MCDCTrackingStateAddr be more appropriate? It could save people some time tracking back up to the comment to work out what Temp is being used for.

peter.smith: Would MCDCTrackingStateAddr be more appropriate? It could save people some time tracking back…
/// Calculate branch weights appropriate for PGO data /// Calculate branch weights appropriate for PGO data
llvm::MDNode *createProfileWeights(uint64_t TrueCount, llvm::MDNode *createProfileWeights(uint64_t TrueCount,
uint64_t FalseCount) const; uint64_t FalseCount) const;
llvm::MDNode *createProfileWeights(ArrayRef<uint64_t> Weights) const; llvm::MDNode *createProfileWeights(ArrayRef<uint64_t> Weights) const;
llvm::MDNode *createProfileWeightsForLoop(const Stmt *Cond, llvm::MDNode *createProfileWeightsForLoop(const Stmt *Cond,
uint64_t LoopCount) const; uint64_t LoopCount) const;
public: public:
/// Increment the profiler's counter for the given statement by \p StepV. /// Increment the profiler's counter for the given statement by \p StepV.
/// If \p StepV is null, the default increment is 1. /// If \p StepV is null, the default increment is 1.
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV = nullptr) { void incrementProfileCounter(const Stmt *S, llvm::Value *StepV = nullptr) {
if (CGM.getCodeGenOpts().hasProfileClangInstr() && if (CGM.getCodeGenOpts().hasProfileClangInstr() &&
!CurFn->hasFnAttribute(llvm::Attribute::NoProfile) && !CurFn->hasFnAttribute(llvm::Attribute::NoProfile) &&
!CurFn->hasFnAttribute(llvm::Attribute::SkipProfile)) !CurFn->hasFnAttribute(llvm::Attribute::SkipProfile))
PGO.emitCounterIncrement(Builder, S, StepV); PGO.emitCounterIncrement(Builder, S, StepV);
PGO.setCurrentStmt(S); PGO.setCurrentStmt(S);
} }
bool isMCDCCoverageEnabled() {
peter.smithUnsubmitted
Not Done
ReplyInline Actions

Can this be bool isMCDCCoverageEnabled() const

peter.smith: Can this be `bool isMCDCCoverageEnabled() const`
return (CGM.getCodeGenOpts().hasProfileClangInstr() &&
CGM.getCodeGenOpts().MCDCCoverage &&
!CurFn->hasFnAttribute(llvm::Attribute::NoProfile));
}
/// Allocate a temp value on the stack that MCDC can use to track condition
/// results.
void createMCDCTempValue() {
if (isMCDCCoverageEnabled()) {
PGO.emitMCDCParameters(Builder);
MCDCTempAddr = CreateIRTemp(getContext().UnsignedIntTy, "mcdc.addr");
return;
peter.smithUnsubmitted
Not Done
ReplyInline Actions

Is the return necessary here?

peter.smith: Is the return necessary here?
}
}
bool isBinaryLogicalOp(const Expr *S) {
peter.smithUnsubmitted
Not Done
ReplyInline Actions

This looks like it doesn't need to be a member function? I can appreciate that here may be the most convenient place to put it though.

peter.smith: This looks like it doesn't need to be a member function? I can appreciate that here may be the…
const BinaryOperator *BOp = dyn_cast<BinaryOperator>(S->IgnoreParens());
return (BOp && BOp->isLogicalOp());
}
/// Zero-init the MCDC temp value.
void resetMCDCTempValue(const Expr *S) {
if (isMCDCCoverageEnabled() && isBinaryLogicalOp(S)) {
PGO.emitMCDCTempReset(Builder, S, MCDCTempAddr);
PGO.setCurrentStmt(S);
}
}
/// Increment the profiler's counter for the given statement by \p StepV.
/// If \p StepV is null, the default increment is 1.
void updateMCDCBitmask(const Expr *S) {
if (isMCDCCoverageEnabled() && isBinaryLogicalOp(S)) {
PGO.emitMCDCBitmaskUpdate(Builder, S, MCDCTempAddr);
PGO.setCurrentStmt(S);
}
}
/// Update the MCDC temp value with the condition's evaluated result.
void updateMCDCTempValue(const Expr *S, llvm::Value *Val) {
if (isMCDCCoverageEnabled()) {
PGO.emitMCDCTempUpdate(Builder, S, MCDCTempAddr, Val);
PGO.setCurrentStmt(S);
}
}
/// Get the profiler's count for the given statement. /// Get the profiler's count for the given statement.
uint64_t getProfileCount(const Stmt *S) { uint64_t getProfileCount(const Stmt *S) {
return PGO.getStmtCount(S).value_or(0); return PGO.getStmtCount(S).value_or(0);
} }
/// Set the profiler's current count. /// Set the profiler's current count.
void setCurrentProfileCount(uint64_t Count) { void setCurrentProfileCount(uint64_t Count) {
PGO.setCurrentRegionCount(Count); PGO.setCurrentRegionCount(Count);
▲ Show 20 Lines • Show All 3,023 Lines • ▼ Show 20 Linespublic:
/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
/// if statement) to the specified blocks. Based on the condition, this might /// if statement) to the specified blocks. Based on the condition, this might
/// try to simplify the codegen of the conditional based on the branch. /// try to simplify the codegen of the conditional based on the branch.
/// TrueCount should be the number of times we expect the condition to /// TrueCount should be the number of times we expect the condition to
/// evaluate to true based on PGO data. /// evaluate to true based on PGO data.
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
llvm::BasicBlock *FalseBlock, uint64_t TrueCount, llvm::BasicBlock *FalseBlock, uint64_t TrueCount,
Stmt::Likelihood LH = Stmt::LH_None); Stmt::Likelihood LH = Stmt::LH_None,
const Expr *ConditionalOp = nullptr);
/// Given an assignment `*LHS = RHS`, emit a test that checks if \p RHS is /// Given an assignment `*LHS = RHS`, emit a test that checks if \p RHS is
/// nonnull, if \p LHS is marked _Nonnull. /// nonnull, if \p LHS is marked _Nonnull.
void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc); void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc);
/// An enumeration which makes it easier to specify whether or not an /// An enumeration which makes it easier to specify whether or not an
/// operation is a subtraction. /// operation is a subtraction.
enum { NotSubtraction = false, IsSubtraction = true }; enum { NotSubtraction = false, IsSubtraction = true };
▲ Show 20 Lines • Show All 284 Lines • Show Last 20 Lines

clang/lib/CodeGen/CodeGenFunction.cpp

Show First 20 Lines • Show All 1,229 Lines • ▼ Show 20 Lines#undef SANITIZER
// target-features/target-cpu? // target-features/target-cpu?
if (CurFuncDecl) if (CurFuncDecl)
if (const auto *VecWidth = CurFuncDecl->getAttr<MinVectorWidthAttr>()) if (const auto *VecWidth = CurFuncDecl->getAttr<MinVectorWidthAttr>())
LargestVectorWidth = VecWidth->getVectorWidth(); LargestVectorWidth = VecWidth->getVectorWidth();
} }
void CodeGenFunction::EmitFunctionBody(const Stmt *Body) { void CodeGenFunction::EmitFunctionBody(const Stmt *Body) {
incrementProfileCounter(Body); incrementProfileCounter(Body);
createMCDCTempValue();
if (const CompoundStmt *S = dyn_cast<CompoundStmt>(Body)) if (const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
EmitCompoundStmtWithoutScope(*S); EmitCompoundStmtWithoutScope(*S);
else else
EmitStmt(Body); EmitStmt(Body);
// This is checked after emitting the function body so we know if there // This is checked after emitting the function body so we know if there
// are any permitted infinite loops. // are any permitted infinite loops.
if (checkIfFunctionMustProgress()) if (checkIfFunctionMustProgress())
▲ Show 20 Lines • Show All 318 Lines • ▼ Show 20 Lines
} }
/// ConstantFoldsToSimpleInteger - If the specified expression does not fold /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
/// to a constant, or if it does but contains a label, return false. If it /// to a constant, or if it does but contains a label, return false. If it
/// constant folds return true and set the boolean result in Result. /// constant folds return true and set the boolean result in Result.
bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond, bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond,
bool &ResultBool, bool &ResultBool,
bool AllowLabels) { bool AllowLabels) {
// If MC/DC is enabled, disable folding so that we can instrument all
// conditions to yield complete test vectors. We still keep track of
// folded conditions during region mapping and visualization.
if (CGM.getCodeGenOpts().hasProfileClangInstr() &&
CGM.getCodeGenOpts().MCDCCoverage)
return false;
llvm::APSInt ResultInt; llvm::APSInt ResultInt;
if (!ConstantFoldsToSimpleInteger(Cond, ResultInt, AllowLabels)) if (!ConstantFoldsToSimpleInteger(Cond, ResultInt, AllowLabels))
return false; return false;
ResultBool = ResultInt.getBoolValue(); ResultBool = ResultInt.getBoolValue();
return true; return true;
} }
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Linesvoid CodeGenFunction::EmitBranchToCounterBlock(
// Go to the next block. // Go to the next block.
EmitBranch(NextBlock); EmitBranch(NextBlock);
} }
/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
/// statement) to the specified blocks. Based on the condition, this might try /// statement) to the specified blocks. Based on the condition, this might try
/// to simplify the codegen of the conditional based on the branch. /// to simplify the codegen of the conditional based on the branch.
/// \param LH The value of the likelihood attribute on the True branch. /// \param LH The value of the likelihood attribute on the True branch.
void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, void CodeGenFunction::EmitBranchOnBoolExpr(
llvm::BasicBlock *TrueBlock, const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock,
llvm::BasicBlock *FalseBlock, uint64_t TrueCount, Stmt::Likelihood LH, const Expr *ConditionalOp) {
uint64_t TrueCount,
Stmt::Likelihood LH) {
Cond = Cond->IgnoreParens(); Cond = Cond->IgnoreParens();
if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
// Handle X && Y in a condition. // Handle X && Y in a condition.
if (CondBOp->getOpcode() == BO_LAnd) { if (CondBOp->getOpcode() == BO_LAnd) {
MCDCLogOpStack.push_back(CondBOp);
// If we have "1 && X", simplify the code. "0 && X" would have constant // If we have "1 && X", simplify the code. "0 && X" would have constant
// folded if the case was simple enough. // folded if the case was simple enough.
bool ConstantBool = false; bool ConstantBool = false;
if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
ConstantBool) { ConstantBool) {
// br(1 && X) -> br(X). // br(1 && X) -> br(X).
incrementProfileCounter(CondBOp); incrementProfileCounter(CondBOp);
return EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LAnd, TrueBlock, EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LAnd, TrueBlock,
FalseBlock, TrueCount, LH); FalseBlock, TrueCount, LH);
MCDCLogOpStack.pop_back();
return;
} }
// If we have "X && 1", simplify the code to use an uncond branch. // If we have "X && 1", simplify the code to use an uncond branch.
// "X && 0" would have been constant folded to 0. // "X && 0" would have been constant folded to 0.
if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
ConstantBool) { ConstantBool) {
// br(X && 1) -> br(X). // br(X && 1) -> br(X).
return EmitBranchToCounterBlock(CondBOp->getLHS(), BO_LAnd, TrueBlock, EmitBranchToCounterBlock(CondBOp->getLHS(), BO_LAnd, TrueBlock,
FalseBlock, TrueCount, LH, CondBOp); FalseBlock, TrueCount, LH, CondBOp);
MCDCLogOpStack.pop_back();
return;
} }
// Emit the LHS as a conditional. If the LHS conditional is false, we // Emit the LHS as a conditional. If the LHS conditional is false, we
// want to jump to the FalseBlock. // want to jump to the FalseBlock.
llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true"); llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true");
// The counter tells us how often we evaluate RHS, and all of TrueCount // The counter tells us how often we evaluate RHS, and all of TrueCount
// can be propagated to that branch. // can be propagated to that branch.
uint64_t RHSCount = getProfileCount(CondBOp->getRHS()); uint64_t RHSCount = getProfileCount(CondBOp->getRHS());
Show All 12 Lines if (CondBOp->getOpcode() == BO_LAnd) {
incrementProfileCounter(CondBOp); incrementProfileCounter(CondBOp);
setCurrentProfileCount(getProfileCount(CondBOp->getRHS())); setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
// Any temporaries created here are conditional. // Any temporaries created here are conditional.
eval.begin(*this); eval.begin(*this);
EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LAnd, TrueBlock, EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LAnd, TrueBlock,
FalseBlock, TrueCount, LH); FalseBlock, TrueCount, LH);
eval.end(*this); eval.end(*this);
MCDCLogOpStack.pop_back();
return; return;
} }
if (CondBOp->getOpcode() == BO_LOr) { if (CondBOp->getOpcode() == BO_LOr) {
MCDCLogOpStack.push_back(CondBOp);
// If we have "0 || X", simplify the code. "1 || X" would have constant // If we have "0 || X", simplify the code. "1 || X" would have constant
// folded if the case was simple enough. // folded if the case was simple enough.
bool ConstantBool = false; bool ConstantBool = false;
if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
!ConstantBool) { !ConstantBool) {
// br(0 || X) -> br(X). // br(0 || X) -> br(X).
incrementProfileCounter(CondBOp); incrementProfileCounter(CondBOp);
return EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LOr, TrueBlock, EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LOr, TrueBlock,
FalseBlock, TrueCount, LH); FalseBlock, TrueCount, LH);
MCDCLogOpStack.pop_back();
return;
} }
// If we have "X || 0", simplify the code to use an uncond branch. // If we have "X || 0", simplify the code to use an uncond branch.
// "X || 1" would have been constant folded to 1. // "X || 1" would have been constant folded to 1.
if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
!ConstantBool) { !ConstantBool) {
// br(X || 0) -> br(X). // br(X || 0) -> br(X).
return EmitBranchToCounterBlock(CondBOp->getLHS(), BO_LOr, TrueBlock, EmitBranchToCounterBlock(CondBOp->getLHS(), BO_LOr, TrueBlock,
FalseBlock, TrueCount, LH, CondBOp); FalseBlock, TrueCount, LH, CondBOp);
MCDCLogOpStack.pop_back();
return;
} }
// Emit the LHS as a conditional. If the LHS conditional is true, we // Emit the LHS as a conditional. If the LHS conditional is true, we
// want to jump to the TrueBlock. // want to jump to the TrueBlock.
llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false"); llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false");
// We have the count for entry to the RHS and for the whole expression // We have the count for entry to the RHS and for the whole expression
// being true, so we can divy up True count between the short circuit and // being true, so we can divy up True count between the short circuit and
// the RHS. // the RHS.
uint64_t LHSCount = uint64_t LHSCount =
getCurrentProfileCount() - getProfileCount(CondBOp->getRHS()); getCurrentProfileCount() - getProfileCount(CondBOp->getRHS());
Show All 14 Lines if (CondBOp->getOpcode() == BO_LOr) {
setCurrentProfileCount(getProfileCount(CondBOp->getRHS())); setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
// Any temporaries created here are conditional. // Any temporaries created here are conditional.
eval.begin(*this); eval.begin(*this);
EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LOr, TrueBlock, FalseBlock, EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LOr, TrueBlock, FalseBlock,
RHSCount, LH); RHSCount, LH);
eval.end(*this); eval.end(*this);
MCDCLogOpStack.pop_back();
return; return;
} }
} }
if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
// br(!x, t, f) -> br(x, f, t) // br(!x, t, f) -> br(x, f, t)
if (CondUOp->getOpcode() == UO_LNot) { if (CondUOp->getOpcode() == UO_LNot) {
// Negate the count. // Negate the count.
Show All 30 Lines if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) {
} }
cond.begin(*this); cond.begin(*this);
EmitBlock(LHSBlock); EmitBlock(LHSBlock);
incrementProfileCounter(CondOp); incrementProfileCounter(CondOp);
{ {
ApplyDebugLocation DL(*this, Cond); ApplyDebugLocation DL(*this, Cond);
EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock, EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock,
LHSScaledTrueCount, LH); LHSScaledTrueCount, LH, CondOp);
} }
cond.end(*this); cond.end(*this);
cond.begin(*this); cond.begin(*this);
EmitBlock(RHSBlock); EmitBlock(RHSBlock);
EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock, EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock,
TrueCount - LHSScaledTrueCount, LH); TrueCount - LHSScaledTrueCount, LH, CondOp);
cond.end(*this); cond.end(*this);
return; return;
} }
if (const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) { if (const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) {
// Conditional operator handling can give us a throw expression as a // Conditional operator handling can give us a throw expression as a
// condition for a case like: // condition for a case like:
// br(c ? throw x : y, t, f) -> br(c, br(throw x, t, f), br(y, t, f) // br(c ? throw x : y, t, f) -> br(c, br(throw x, t, f), br(y, t, f)
// Fold this to: // Fold this to:
// br(c, throw x, br(y, t, f)) // br(c, throw x, br(y, t, f))
EmitCXXThrowExpr(Throw, /*KeepInsertionPoint*/false); EmitCXXThrowExpr(Throw, /*KeepInsertionPoint*/false);
return; return;
} }
// Emit the code with the fully general case. // Emit the code with the fully general case.
llvm::Value *CondV; llvm::Value *CondV;
{ {
ApplyDebugLocation DL(*this, Cond); ApplyDebugLocation DL(*this, Cond);
CondV = EvaluateExprAsBool(Cond); CondV = EvaluateExprAsBool(Cond);
} }
// If not at the top of the logical operator nest, update MCDC temp with the
// boolean result of the evaluated condition.
if (!MCDCLogOpStack.empty()) {
const Expr *MCDCBaseExpr = Cond;
// When a nested ConditionalOperator (ternary) is encountered in a boolean
// expression, MC/DC tracks the result of the ternary, and this is tied to
// the ConditionalOperator expression and not the ternary's LHS or RHS. If
// this is the case, the ConditionalOperator expression is passed through
// the ConditionalOp parameter and then used as the MCDC base expression.
if (ConditionalOp)
MCDCBaseExpr = ConditionalOp;
updateMCDCTempValue(MCDCBaseExpr, CondV);
}
llvm::MDNode *Weights = nullptr; llvm::MDNode *Weights = nullptr;
llvm::MDNode *Unpredictable = nullptr; llvm::MDNode *Unpredictable = nullptr;
// If the branch has a condition wrapped by __builtin_unpredictable, // If the branch has a condition wrapped by __builtin_unpredictable,
// create metadata that specifies that the branch is unpredictable. // create metadata that specifies that the branch is unpredictable.
// Don't bother if not optimizing because that metadata would not be used. // Don't bother if not optimizing because that metadata would not be used.
auto *Call = dyn_cast<CallExpr>(Cond->IgnoreImpCasts()); auto *Call = dyn_cast<CallExpr>(Cond->IgnoreImpCasts());
if (Call && CGM.getCodeGenOpts().OptimizationLevel != 0) { if (Call && CGM.getCodeGenOpts().OptimizationLevel != 0) {
▲ Show 20 Lines • Show All 915 Lines • Show Last 20 Lines

clang/lib/CodeGen/CodeGenPGO.h

Show All 26 Lines
class CodeGenPGO { class CodeGenPGO {
private: private:
CodeGenModule &CGM; CodeGenModule &CGM;
std::string FuncName; std::string FuncName;
llvm::GlobalVariable *FuncNameVar; llvm::GlobalVariable *FuncNameVar;
std::array <unsigned, llvm::IPVK_Last + 1> NumValueSites; std::array <unsigned, llvm::IPVK_Last + 1> NumValueSites;
unsigned NumRegionCounters; unsigned NumRegionCounters;
unsigned MCDCBitmaskBytes;
uint64_t FunctionHash; uint64_t FunctionHash;
std::unique_ptr<llvm::DenseMap<const Stmt *, unsigned>> RegionCounterMap; std::unique_ptr<llvm::DenseMap<const Stmt *, unsigned>> RegionCounterMap;
std::unique_ptr<llvm::DenseMap<const Stmt *, unsigned>> RegionBitmaskMap;
std::unique_ptr<llvm::DenseMap<const Stmt *, unsigned>> RegionCondIDMap;
std::unique_ptr<llvm::DenseMap<const Stmt *, uint64_t>> StmtCountMap; std::unique_ptr<llvm::DenseMap<const Stmt *, uint64_t>> StmtCountMap;
std::unique_ptr<llvm::InstrProfRecord> ProfRecord; std::unique_ptr<llvm::InstrProfRecord> ProfRecord;
std::vector<uint64_t> RegionCounts; std::vector<uint64_t> RegionCounts;
uint64_t CurrentRegionCount; uint64_t CurrentRegionCount;
public: public:
CodeGenPGO(CodeGenModule &CGModule) CodeGenPGO(CodeGenModule &CGModule)
: CGM(CGModule), FuncNameVar(nullptr), NumValueSites({{0}}), : CGM(CGModule), FuncNameVar(nullptr), NumValueSites({{0}}),
NumRegionCounters(0), FunctionHash(0), CurrentRegionCount(0) {} NumRegionCounters(0), MCDCBitmaskBytes(0), FunctionHash(0),
CurrentRegionCount(0) {}
/// Whether or not we have PGO region data for the current function. This is /// Whether or not we have PGO region data for the current function. This is
/// false both when we have no data at all and when our data has been /// false both when we have no data at all and when our data has been
/// discarded. /// discarded.
bool haveRegionCounts() const { return !RegionCounts.empty(); } bool haveRegionCounts() const { return !RegionCounts.empty(); }
/// Return the counter value of the current region. /// Return the counter value of the current region.
uint64_t getCurrentRegionCount() const { return CurrentRegionCount; } uint64_t getCurrentRegionCount() const { return CurrentRegionCount; }
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linesprivate:
void mapRegionCounters(const Decl *D); void mapRegionCounters(const Decl *D);
void computeRegionCounts(const Decl *D); void computeRegionCounts(const Decl *D);
void applyFunctionAttributes(llvm::IndexedInstrProfReader *PGOReader, void applyFunctionAttributes(llvm::IndexedInstrProfReader *PGOReader,
llvm::Function *Fn); llvm::Function *Fn);
void loadRegionCounts(llvm::IndexedInstrProfReader *PGOReader, void loadRegionCounts(llvm::IndexedInstrProfReader *PGOReader,
bool IsInMainFile); bool IsInMainFile);
bool skipRegionMappingForDecl(const Decl *D); bool skipRegionMappingForDecl(const Decl *D);
void emitCounterRegionMapping(const Decl *D); void emitCounterRegionMapping(const Decl *D);
bool canEmitMCDCCoverage(const CGBuilderTy &Builder);
public: public:
void emitCounterIncrement(CGBuilderTy &Builder, const Stmt *S, void emitCounterIncrement(CGBuilderTy &Builder, const Stmt *S,
llvm::Value *StepV); llvm::Value *StepV);
void emitMCDCBitmaskUpdate(CGBuilderTy &Builder, const Expr *S,
Address TempAddr);
void emitMCDCParameters(CGBuilderTy &Builder);
void emitMCDCTempReset(CGBuilderTy &Builder, const Expr *S, Address TempAddr);
void emitMCDCTempUpdate(CGBuilderTy &Builder, const Expr *S, Address TempAddr,
llvm::Value *Val);
/// Return the region count for the counter at the given index. /// Return the region count for the counter at the given index.
uint64_t getRegionCount(const Stmt *S) { uint64_t getRegionCount(const Stmt *S) {
if (!RegionCounterMap) if (!RegionCounterMap)
return 0; return 0;
if (!haveRegionCounts()) if (!haveRegionCounts())
return 0; return 0;
return RegionCounts[(*RegionCounterMap)[S]]; return RegionCounts[(*RegionCounterMap)[S]];
} }
}; };
} // end namespace CodeGen } // end namespace CodeGen
} // end namespace clang } // end namespace clang
#endif #endif

clang/lib/CodeGen/CodeGenPGO.cpp

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Linesstruct MapRegionCounters : public RecursiveASTVisitor<MapRegionCounters> {
using Base = RecursiveASTVisitor<MapRegionCounters>; using Base = RecursiveASTVisitor<MapRegionCounters>;
/// The next counter value to assign. /// The next counter value to assign.
unsigned NextCounter; unsigned NextCounter;
/// The function hash. /// The function hash.
PGOHash Hash; PGOHash Hash;
/// The map of statements to counters. /// The map of statements to counters.
llvm::DenseMap<const Stmt *, unsigned> &CounterMap; llvm::DenseMap<const Stmt *, unsigned> &CounterMap;
/// The next bitmask byte index to assign.
unsigned NextBitmask;
peter.smithUnsubmitted
Not Done
ReplyInline Actions

perhaps worth including index in the name, for example NextBitmaskIdx . Will help prevent confusion as to whether this is an index or an actual bitmask (comment does say, but harder to see from reading the code).

peter.smith: perhaps worth including index in the name, for example `NextBitmaskIdx` . Will help prevent…
/// The map of statements to bitmask coverage objects.
llvm::DenseMap<const Stmt *, unsigned> &BitmaskMap;
/// Maximum number of supported MC/DC conditions in a boolean expression.
unsigned MaxCond;
/// The profile version. /// The profile version.
uint64_t ProfileVersion; uint64_t ProfileVersion;
/// Diagnostics Engine used to report warnings.
DiagnosticsEngine &Diag;
/// Whether counters are limited only to functions.
bool FunctionCoverageOnly;
MapRegionCounters(PGOHashVersion HashVersion, uint64_t ProfileVersion, MapRegionCounters(PGOHashVersion HashVersion, uint64_t ProfileVersion,
llvm::DenseMap<const Stmt *, unsigned> &CounterMap) llvm::DenseMap<const Stmt *, unsigned> &CounterMap,
llvm::DenseMap<const Stmt *, unsigned> &BitmaskMap,
unsigned MaxCond, DiagnosticsEngine &Diag)
: NextCounter(0), Hash(HashVersion), CounterMap(CounterMap), : NextCounter(0), Hash(HashVersion), CounterMap(CounterMap),
ProfileVersion(ProfileVersion) {} NextBitmask(0), BitmaskMap(BitmaskMap), MaxCond(MaxCond),
ProfileVersion(ProfileVersion), Diag(Diag) {}
// Blocks and lambdas are handled as separate functions, so we need not // Blocks and lambdas are handled as separate functions, so we need not
// traverse them in the parent context. // traverse them in the parent context.
bool TraverseBlockExpr(BlockExpr *BE) { return true; } bool TraverseBlockExpr(BlockExpr *BE) { return true; }
bool TraverseLambdaExpr(LambdaExpr *LE) { bool TraverseLambdaExpr(LambdaExpr *LE) {
// Traverse the captures, but not the body. // Traverse the captures, but not the body.
for (auto C : zip(LE->captures(), LE->capture_inits())) for (auto C : zip(LE->captures(), LE->capture_inits()))
TraverseLambdaCapture(LE, &std::get<0>(C), std::get<1>(C)); TraverseLambdaCapture(LE, &std::get<0>(C), std::get<1>(C));
Show All 23 Linesstruct MapRegionCounters : public RecursiveASTVisitor<MapRegionCounters> {
/// V1 hash of \p S. /// V1 hash of \p S.
PGOHash::HashType updateCounterMappings(Stmt *S) { PGOHash::HashType updateCounterMappings(Stmt *S) {
auto Type = getHashType(PGO_HASH_V1, S); auto Type = getHashType(PGO_HASH_V1, S);
if (Type != PGOHash::None) if (Type != PGOHash::None)
CounterMap[S] = NextCounter++; CounterMap[S] = NextCounter++;
return Type; return Type;
} }
/// The following stacks are used with dataTraverseStmtPre() and
/// dataTraverseStmtPost() to track the depth of nested logical operators in a
/// boolean expression in a function. The ultimate purpose is to keep track
/// of the number of leaf-level conditions in the boolean expression so that a
/// profile bitmask can be allocated based on that number.
///
/// The stacks are also used to find error cases and notify the user. A
/// standard logical operator nest for a boolean expression could be in a form
/// similar to this: "x = a && b && c && (d || f)"
unsigned NumCond = 0;
bool SplitNestedLogicalOp = false;
SmallVector<const Stmt *, 16> NonLogOpStack;
SmallVector<const BinaryOperator *, 16> LogOpStack;
// Hook: dataTraverseStmtPre() is invoked prior to visiting an AST Stmt node.
bool dataTraverseStmtPre(Stmt *S) {
/// If MC/DC is not enabled, MaxCond will be set to 0. Don't do anything.
if (MaxCond == 0)
return true;
/// At the top of the logical operator nest, reset the number of conditions.
if (LogOpStack.empty())
NumCond = 0;
if (isa<Expr>(S)) {
const Expr *E = reinterpret_cast<Expr *>(S);
const BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E->IgnoreParens());
if (BinOp && BinOp->isLogicalOp()) {
/// Check for "split-nested" logical operators. This happens when a new
/// boolean expression logical-op nest is encountered within an existing
/// boolean expression, separated by a non-logical operator. For
/// example, in "x = (a && b && c && foo(d && f))", the "d && f" case
/// starts a new boolean expression that is separated from the other
/// conditions by the operator foo(). Split-nested cases are not
/// supported by MC/DC.
SplitNestedLogicalOp = SplitNestedLogicalOp || !NonLogOpStack.empty();
LogOpStack.push_back(BinOp);
return true;
}
}
if (!LogOpStack.empty()) {
/// Keep track of non-logical operators. These are OK as long as we don't
/// encounter a new logical operator after seeing one.
NonLogOpStack.push_back(S);
}
return true;
}
// Hook: dataTraverseStmtPost() is invoked by the AST visitor after visiting
// an AST Stmt node. MC/DC will use it to to signal when the top of a
// logical operation (boolean expression) nest is encountered.
bool dataTraverseStmtPost(Stmt *S) {
/// If MC/DC is not enabled, MaxCond will be set to 0. Don't do anything.
if (MaxCond == 0)
return true;
if (isa<Expr>(S)) {
const Expr *E = reinterpret_cast<Expr *>(S);
const BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E->IgnoreParens());
if (BinOp && BinOp->isLogicalOp()) {
assert(LogOpStack.back() == BinOp);
LogOpStack.pop_back();
/// At the top of logical operator nest:
if (LogOpStack.empty()) {
/// Was the "split-nested" logical operator case encountered?
if (SplitNestedLogicalOp) {
unsigned DiagID = Diag.getCustomDiagID(
DiagnosticsEngine::Error,
"MC/DC: Unsupported boolean expression; "
"contains an operation with a nested boolean expression.");
Diag.Report(S->getBeginLoc(), DiagID);
return false;
/// Was the maximum number of conditions encountered?
} else if (NumCond > MaxCond) {
unsigned DiagID = Diag.getCustomDiagID(
DiagnosticsEngine::Error,
"MC/DC: Unsupported boolean expression; "
"number of conditions (%0) exceeds max (%1).");
Diag.Report(S->getBeginLoc(), DiagID) << NumCond << MaxCond;
return false;
// Otherwise, allocate the number of bytes required for the bitmask
// based on the number of conditions. Must be at least 1-byte long.
} else {
BitmaskMap[BinOp] = NextBitmask;
unsigned SizeInBits = llvm::alignTo(1L << NumCond, CHAR_BIT);
NextBitmask += (SizeInBits / CHAR_BIT);
}
}
return true;
}
}
if (!LogOpStack.empty()) {
NonLogOpStack.pop_back();
}
return true;
}
/// The RHS of all logical operators gets a fresh counter in order to count /// The RHS of all logical operators gets a fresh counter in order to count
/// how many times the RHS evaluates to true or false, depending on the /// how many times the RHS evaluates to true or false, depending on the
/// semantics of the operator. This is only valid for ">= v7" of the profile /// semantics of the operator. This is only valid for ">= v7" of the profile
/// version so that we facilitate backward compatibility. /// version so that we facilitate backward compatibility. In addition, in
/// order to use MC/DC, count the number of total LHS and RHS conditions.
bool VisitBinaryOperator(BinaryOperator *S) { bool VisitBinaryOperator(BinaryOperator *S) {
if (ProfileVersion >= llvm::IndexedInstrProf::Version7) if (ProfileVersion >= llvm::IndexedInstrProf::Version7) {
if (S->isLogicalOp() && if (S->isLogicalOp()) {
CodeGenFunction::isInstrumentedCondition(S->getRHS())) if (CodeGenFunction::isInstrumentedCondition(S->getLHS())) {
NumCond++;
}
if (CodeGenFunction::isInstrumentedCondition(S->getRHS())) {
CounterMap[S->getRHS()] = NextCounter++; CounterMap[S->getRHS()] = NextCounter++;
NumCond++;
}
}
}
return Base::VisitBinaryOperator(S); return Base::VisitBinaryOperator(S);
} }
/// Include \p S in the function hash. /// Include \p S in the function hash.
bool VisitStmt(Stmt *S) { bool VisitStmt(Stmt *S) {
auto Type = updateCounterMappings(S); auto Type = updateCounterMappings(S);
if (Hash.getHashVersion() != PGO_HASH_V1) if (Hash.getHashVersion() != PGO_HASH_V1)
Type = getHashType(Hash.getHashVersion(), S); Type = getHashType(Hash.getHashVersion(), S);
▲ Show 20 Lines • Show All 617 Lines • ▼ Show 20 Linesvoid CodeGenPGO::mapRegionCounters(const Decl *D) {
// version in the indexed profile if we're reading PGO data. // version in the indexed profile if we're reading PGO data.
PGOHashVersion HashVersion = PGO_HASH_LATEST; PGOHashVersion HashVersion = PGO_HASH_LATEST;
uint64_t ProfileVersion = llvm::IndexedInstrProf::Version; uint64_t ProfileVersion = llvm::IndexedInstrProf::Version;
if (auto *PGOReader = CGM.getPGOReader()) { if (auto *PGOReader = CGM.getPGOReader()) {
HashVersion = getPGOHashVersion(PGOReader, CGM); HashVersion = getPGOHashVersion(PGOReader, CGM);
ProfileVersion = PGOReader->getVersion(); ProfileVersion = PGOReader->getVersion();
} }
// If MC/DC is enabled, set the MaxConditions to the preset value. Otherwise,
// set it to zero.
unsigned MCDCMaxConditions = 0;
peter.smithUnsubmitted
Not Done
ReplyInline Actions

unsigned MCDCMaxConditions = (CGM.getCodeGenOpts().MCDCCoverage) ? CGM.getCodeGenOpts().MCDCMaxConditionCount : 0;

Purely subjective opinion on my part though.

peter.smith: `unsigned MCDCMaxConditions = (CGM.getCodeGenOpts().MCDCCoverage) ? CGM.getCodeGenOpts().
if (CGM.getCodeGenOpts().MCDCCoverage)
MCDCMaxConditions = CGM.getCodeGenOpts().MCDCMaxConditionCount;
RegionCounterMap.reset(new llvm::DenseMap<const Stmt *, unsigned>); RegionCounterMap.reset(new llvm::DenseMap<const Stmt *, unsigned>);
MapRegionCounters Walker(HashVersion, ProfileVersion, *RegionCounterMap); RegionBitmaskMap.reset(new llvm::DenseMap<const Stmt *, unsigned>);
MapRegionCounters Walker(HashVersion, ProfileVersion, *RegionCounterMap,
*RegionBitmaskMap, MCDCMaxConditions,
CGM.getDiags());
if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
Walker.TraverseDecl(const_cast<FunctionDecl *>(FD)); Walker.TraverseDecl(const_cast<FunctionDecl *>(FD));
else if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D)) else if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D))
Walker.TraverseDecl(const_cast<ObjCMethodDecl *>(MD)); Walker.TraverseDecl(const_cast<ObjCMethodDecl *>(MD));
else if (const BlockDecl *BD = dyn_cast_or_null<BlockDecl>(D)) else if (const BlockDecl *BD = dyn_cast_or_null<BlockDecl>(D))
Walker.TraverseDecl(const_cast<BlockDecl *>(BD)); Walker.TraverseDecl(const_cast<BlockDecl *>(BD));
else if (const CapturedDecl *CD = dyn_cast_or_null<CapturedDecl>(D)) else if (const CapturedDecl *CD = dyn_cast_or_null<CapturedDecl>(D))
Walker.TraverseDecl(const_cast<CapturedDecl *>(CD)); Walker.TraverseDecl(const_cast<CapturedDecl *>(CD));
assert(Walker.NextCounter > 0 && "no entry counter mapped for decl"); assert(Walker.NextCounter > 0 && "no entry counter mapped for decl");
NumRegionCounters = Walker.NextCounter; NumRegionCounters = Walker.NextCounter;
MCDCBitmaskBytes = Walker.NextBitmask;
FunctionHash = Walker.Hash.finalize(); FunctionHash = Walker.Hash.finalize();
} }
bool CodeGenPGO::skipRegionMappingForDecl(const Decl *D) { bool CodeGenPGO::skipRegionMappingForDecl(const Decl *D) {
if (!D->getBody()) if (!D->getBody())
return true; return true;
// Skip host-only functions in the CUDA device compilation and device-only // Skip host-only functions in the CUDA device compilation and device-only
Show All 15 Lines
} }
void CodeGenPGO::emitCounterRegionMapping(const Decl *D) { void CodeGenPGO::emitCounterRegionMapping(const Decl *D) {
if (skipRegionMappingForDecl(D)) if (skipRegionMappingForDecl(D))
return; return;
std::string CoverageMapping; std::string CoverageMapping;
llvm::raw_string_ostream OS(CoverageMapping); llvm::raw_string_ostream OS(CoverageMapping);
RegionCondIDMap.reset(new llvm::DenseMap<const Stmt *, unsigned>);
CoverageMappingGen MappingGen(*CGM.getCoverageMapping(), CoverageMappingGen MappingGen(*CGM.getCoverageMapping(),
CGM.getContext().getSourceManager(), CGM.getContext().getSourceManager(),
CGM.getLangOpts(), RegionCounterMap.get()); CGM.getLangOpts(), RegionCounterMap.get(),
RegionBitmaskMap.get(), RegionCondIDMap.get());
MappingGen.emitCounterMapping(D, OS); MappingGen.emitCounterMapping(D, OS);
OS.flush(); OS.flush();
if (CoverageMapping.empty()) if (CoverageMapping.empty())
return; return;
CGM.getCoverageMapping()->addFunctionMappingRecord( CGM.getCoverageMapping()->addFunctionMappingRecord(
FuncNameVar, FuncName, FunctionHash, CoverageMapping); FuncNameVar, FuncName, FunctionHash, CoverageMapping);
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines if (!StepV)
Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::instrprof_increment), Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::instrprof_increment),
makeArrayRef(Args, 4)); makeArrayRef(Args, 4));
else else
Builder.CreateCall( Builder.CreateCall(
CGM.getIntrinsic(llvm::Intrinsic::instrprof_increment_step), CGM.getIntrinsic(llvm::Intrinsic::instrprof_increment_step),
makeArrayRef(Args)); makeArrayRef(Args));
} }
bool CodeGenPGO::canEmitMCDCCoverage(const CGBuilderTy &Builder) {
return (CGM.getCodeGenOpts().hasProfileClangInstr() &&
CGM.getCodeGenOpts().MCDCCoverage &&
Builder.GetInsertBlock());
}
void CodeGenPGO::emitMCDCParameters(CGBuilderTy &Builder) {
if (!canEmitMCDCCoverage(Builder) || !RegionBitmaskMap)
return;
auto *I8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
// Emit intrinsic representing MCDC bitmask parameters at function entry.
// This is used by the instrumentation pass, but it isn't actually lowered to
// anything.
llvm::Value *Args[3] = {llvm::ConstantExpr::getBitCast(FuncNameVar, I8PtrTy),
Builder.getInt64(FunctionHash),
Builder.getInt32(MCDCBitmaskBytes)};
Builder.CreateCall(
CGM.getIntrinsic(llvm::Intrinsic::instrprof_mcdc_parameters), Args);
}
void CodeGenPGO::emitMCDCBitmaskUpdate(CGBuilderTy &Builder, const Expr *S,
Address TempAddr) {
if (!canEmitMCDCCoverage(Builder) || !RegionBitmaskMap)
return;
S = S->IgnoreParens();
if (RegionBitmaskMap->find(S) == RegionBitmaskMap->end())
return;
unsigned Bitmask = (*RegionBitmaskMap)[S];
auto *I8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
// Emit intrinsic responsible for updating the bitmask corresponding to a
// boolean expression. The update is based on the value loaded from a
// pointer to a dedicated temporary value on the stack that is itself updated
// via emitMCDCTempReset() and emitMCDCTempUpdate(). The value represents
// an executed test vector.
llvm::Value *Args[5] = {llvm::ConstantExpr::getBitCast(FuncNameVar, I8PtrTy),
Builder.getInt64(FunctionHash),
Builder.getInt32(MCDCBitmaskBytes),
Builder.getInt32(Bitmask), TempAddr.getPointer()};
Builder.CreateCall(
CGM.getIntrinsic(llvm::Intrinsic::instrprof_mcdc_bitmask_update), Args);
}
void CodeGenPGO::emitMCDCTempReset(CGBuilderTy &Builder, const Expr *S,
Address TempAddr) {
if (!canEmitMCDCCoverage(Builder) || !RegionBitmaskMap)
return;
S = S->IgnoreParens();
if (RegionBitmaskMap->find(S) == RegionBitmaskMap->end())
return;
// Emit intrinsic that resets a dedicated temporary value on the stack to 0.
Builder.CreateStore(Builder.getInt32(0), TempAddr);
}
void CodeGenPGO::emitMCDCTempUpdate(CGBuilderTy &Builder, const Expr *S,
Address TempAddr, llvm::Value *Val) {
if (!canEmitMCDCCoverage(Builder) || !RegionCondIDMap)
return;
if (const UnaryOperator *UnOp = dyn_cast<UnaryOperator>(S->IgnoreParens()))
if (UnOp->getOpcode() == UO_LNot)
S = UnOp->getSubExpr();
S = S->IgnoreParens();
if (RegionCondIDMap->find(S) == RegionCondIDMap->end())
return;
unsigned CondID = (*RegionCondIDMap)[S];
assert(CondID > 0 && "Condition has no ID!");
auto *I8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
// Emit intrinsic that updates a dedicated temporary value on the stack after
// a condition is evaluated. After the set of conditions has been updated,
// the resulting value is used to update the boolean expression's bitmask.
llvm::Value *Args[5] = {llvm::ConstantExpr::getBitCast(FuncNameVar, I8PtrTy),
Builder.getInt64(FunctionHash),
Builder.getInt32(CondID - 1), TempAddr.getPointer(),
Val};
Builder.CreateCall(
CGM.getIntrinsic(llvm::Intrinsic::instrprof_mcdc_temp_update), Args);
}
void CodeGenPGO::setValueProfilingFlag(llvm::Module &M) { void CodeGenPGO::setValueProfilingFlag(llvm::Module &M) {
if (CGM.getCodeGenOpts().hasProfileClangInstr()) if (CGM.getCodeGenOpts().hasProfileClangInstr())
M.addModuleFlag(llvm::Module::Warning, "EnableValueProfiling", M.addModuleFlag(llvm::Module::Warning, "EnableValueProfiling",
uint32_t(EnableValueProfiling)); uint32_t(EnableValueProfiling));
} }
// This method either inserts a call to the profile run-time during // This method either inserts a call to the profile run-time during
// instrumentation or puts profile data into metadata for PGO use. // instrumentation or puts profile data into metadata for PGO use.
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

clang/lib/CodeGen/CoverageMappingGen.h

Show First 20 Lines • Show All 145 Lines • ▼ Show 20 Lines
/// Organizes the per-function state that is used while generating /// Organizes the per-function state that is used while generating
/// code coverage mapping data. /// code coverage mapping data.
class CoverageMappingGen { class CoverageMappingGen {
CoverageMappingModuleGen &CVM; CoverageMappingModuleGen &CVM;
SourceManager &SM; SourceManager &SM;
const LangOptions &LangOpts; const LangOptions &LangOpts;
llvm::DenseMap<const Stmt *, unsigned> *CounterMap; llvm::DenseMap<const Stmt *, unsigned> *CounterMap;
llvm::DenseMap<const Stmt *, unsigned> *BitmaskMap;
llvm::DenseMap<const Stmt *, unsigned> *CondIDMap;
public: public:
CoverageMappingGen(CoverageMappingModuleGen &CVM, SourceManager &SM, CoverageMappingGen(CoverageMappingModuleGen &CVM, SourceManager &SM,
const LangOptions &LangOpts) const LangOptions &LangOpts)
: CVM(CVM), SM(SM), LangOpts(LangOpts), CounterMap(nullptr) {} : CVM(CVM), SM(SM), LangOpts(LangOpts), CounterMap(nullptr),
BitmaskMap(nullptr), CondIDMap(nullptr) {}
CoverageMappingGen(CoverageMappingModuleGen &CVM, SourceManager &SM, CoverageMappingGen(CoverageMappingModuleGen &CVM, SourceManager &SM,
const LangOptions &LangOpts, const LangOptions &LangOpts,
llvm::DenseMap<const Stmt *, unsigned> *CounterMap) llvm::DenseMap<const Stmt *, unsigned> *CounterMap,
: CVM(CVM), SM(SM), LangOpts(LangOpts), CounterMap(CounterMap) {} llvm::DenseMap<const Stmt *, unsigned> *BitmaskMap,
llvm::DenseMap<const Stmt *, unsigned> *CondIDMap)
: CVM(CVM), SM(SM), LangOpts(LangOpts), CounterMap(CounterMap),
BitmaskMap(BitmaskMap), CondIDMap(CondIDMap) {}
/// Emit the coverage mapping data which maps the regions of /// Emit the coverage mapping data which maps the regions of
/// code to counters that will be used to find the execution /// code to counters that will be used to find the execution
/// counts for those regions. /// counts for those regions.
void emitCounterMapping(const Decl *D, llvm::raw_ostream &OS); void emitCounterMapping(const Decl *D, llvm::raw_ostream &OS);
/// Emit the coverage mapping data for an unused function. /// Emit the coverage mapping data for an unused function.
/// It creates mapping regions with the counter of zero. /// It creates mapping regions with the counter of zero.
void emitEmptyMapping(const Decl *D, llvm::raw_ostream &OS); void emitEmptyMapping(const Decl *D, llvm::raw_ostream &OS);
}; };
} // end namespace CodeGen } // end namespace CodeGen
} // end namespace clang } // end namespace clang
#endif #endif

clang/lib/CodeGen/CoverageMappingGen.cpp

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
/// A region of source code that can be mapped to a counter. /// A region of source code that can be mapped to a counter.
class SourceMappingRegion { class SourceMappingRegion {
/// Primary Counter that is also used for Branch Regions for "True" branches. /// Primary Counter that is also used for Branch Regions for "True" branches.
Counter Count; Counter Count;
/// Secondary Counter used for Branch Regions for "False" branches. /// Secondary Counter used for Branch Regions for "False" branches.
Optional<Counter> FalseCount; Optional<Counter> FalseCount;
unsigned Mask = 0;
peter.smithUnsubmitted
Not Done
ReplyInline Actions

Worth a comment that these are associated with MCDC?

peter.smith: Worth a comment that these are associated with MCDC?
unsigned Conditions = 0;
unsigned ID = 0;
unsigned TrueID = 0;
unsigned FalseID = 0;
/// The region's starting location. /// The region's starting location.
Optional<SourceLocation> LocStart; Optional<SourceLocation> LocStart;
/// The region's ending location. /// The region's ending location.
Optional<SourceLocation> LocEnd; Optional<SourceLocation> LocEnd;
/// Whether this region is a gap region. The count from a gap region is set /// Whether this region is a gap region. The count from a gap region is set
/// as the line execution count if there are no other regions on the line. /// as the line execution count if there are no other regions on the line.
bool GapRegion; bool GapRegion;
public: public:
SourceMappingRegion(Counter Count, Optional<SourceLocation> LocStart, SourceMappingRegion(Counter Count, Optional<SourceLocation> LocStart,
Optional<SourceLocation> LocEnd, bool GapRegion = false) Optional<SourceLocation> LocEnd, bool GapRegion = false)
: Count(Count), LocStart(LocStart), LocEnd(LocEnd), GapRegion(GapRegion) { : Count(Count), LocStart(LocStart), LocEnd(LocEnd), GapRegion(GapRegion) {
} }
SourceMappingRegion(Counter Count, Optional<Counter> FalseCount, SourceMappingRegion(Counter Count, Optional<Counter> FalseCount,
unsigned ID, unsigned TrueID, unsigned FalseID,
Optional<SourceLocation> LocStart, Optional<SourceLocation> LocStart,
Optional<SourceLocation> LocEnd, bool GapRegion = false) Optional<SourceLocation> LocEnd, bool GapRegion = false)
: Count(Count), FalseCount(FalseCount), LocStart(LocStart), : Count(Count), FalseCount(FalseCount), ID(ID), TrueID(TrueID),
LocEnd(LocEnd), GapRegion(GapRegion) {} FalseID(FalseID), LocStart(LocStart), LocEnd(LocEnd),
GapRegion(GapRegion) {}
SourceMappingRegion(unsigned Mask, unsigned Conditions,
Optional<SourceLocation> LocStart,
Optional<SourceLocation> LocEnd)
: Mask(Mask), Conditions(Conditions), LocStart(LocStart), LocEnd(LocEnd),
GapRegion(false) {}
const Counter &getCounter() const { return Count; } const Counter &getCounter() const { return Count; }
const Counter &getFalseCounter() const { const Counter &getFalseCounter() const {
assert(FalseCount && "Region has no alternate counter"); assert(FalseCount && "Region has no alternate counter");
return *FalseCount; return *FalseCount;
} }
Show All 20 Lines SourceLocation getEndLoc() const {
return *LocEnd; return *LocEnd;
} }
bool isGap() const { return GapRegion; } bool isGap() const { return GapRegion; }
void setGap(bool Gap) { GapRegion = Gap; } void setGap(bool Gap) { GapRegion = Gap; }
bool isBranch() const { return FalseCount.has_value(); } bool isBranch() const { return FalseCount.has_value(); }
unsigned getID() const { return ID; }
unsigned getTrueID() const { return TrueID; }
unsigned getFalseID() const { return FalseID; }
bool isDecision() const { return Conditions != 0; }
unsigned getMask() const { return Mask; }
unsigned getConditions() const { return Conditions; }
}; };
/// Spelling locations for the start and end of a source region. /// Spelling locations for the start and end of a source region.
struct SpellingRegion { struct SpellingRegion {
/// The line where the region starts. /// The line where the region starts.
unsigned LineStart; unsigned LineStart;
/// The column where the region starts. /// The column where the region starts.
▲ Show 20 Lines • Show All 272 Lines • ▼ Show 20 Lines for (const auto &Region : SourceRegions) {
assert(SR.isInSourceOrder() && "region start and end out of order"); assert(SR.isInSourceOrder() && "region start and end out of order");
if (Region.isGap()) { if (Region.isGap()) {
MappingRegions.push_back(CounterMappingRegion::makeGapRegion( MappingRegions.push_back(CounterMappingRegion::makeGapRegion(
Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart, Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart,
SR.LineEnd, SR.ColumnEnd)); SR.LineEnd, SR.ColumnEnd));
} else if (Region.isBranch()) { } else if (Region.isBranch()) {
MappingRegions.push_back(CounterMappingRegion::makeBranchRegion( MappingRegions.push_back(CounterMappingRegion::makeBranchRegion(
Region.getCounter(), Region.getFalseCounter(), *CovFileID, Region.getCounter(), Region.getFalseCounter(), Region.getID(),
SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd)); Region.getTrueID(), Region.getFalseID(), *CovFileID, SR.LineStart,
SR.ColumnStart, SR.LineEnd, SR.ColumnEnd));
} else if (Region.isDecision()) {
MappingRegions.push_back(CounterMappingRegion::makeDecisionRegion(
Region.getMask(), Region.getConditions(), *CovFileID, SR.LineStart,
SR.ColumnStart, SR.LineEnd, SR.ColumnEnd));
} else { } else {
MappingRegions.push_back(CounterMappingRegion::makeRegion( MappingRegions.push_back(CounterMappingRegion::makeRegion(
Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart, Region.getCounter(), *CovFileID, SR.LineStart, SR.ColumnStart,
SR.LineEnd, SR.ColumnEnd)); SR.LineEnd, SR.ColumnEnd));
} }
} }
} }
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines void write(llvm::raw_ostream &OS) {
if (MappingRegions.empty()) if (MappingRegions.empty())
return; return;
CoverageMappingWriter Writer(FileIDMapping, None, MappingRegions); CoverageMappingWriter Writer(FileIDMapping, None, MappingRegions);
Writer.write(OS); Writer.write(OS);
} }
}; };
/// A wrapper object for maintaining stacks to track the resursive AST visitor
/// walks for the purpose of assigning IDs to leaf-level conditions measured by
/// MC/DC. The object is created with a reference to the BitmaskMap that was
/// created during the initial AST walk. The presence of a bitmask associated
/// with a boolean expression (top-level logical operator nest) indicates that
/// the boolean expression qualified for MC/DC. The resulting condition IDs
/// are preserved in a map reference that is also provided during object
/// creation.
struct MCDCCoverageBuilder {
/// The AST walk recursively visits nested logical-AND or logical-OR binary
/// operator nodes and then visits their LHS and RHS children nodes. As this
/// happens, the algorithm will assign IDs to each operator's LHS and RHS side
/// as the walk moves deeper into the nest. At each level of the recursive
/// nest, the LHS and RHS may actually correspond to larger subtrees (not
/// leaf-conditions). If this is the case, when that node is visited, the ID
/// assigned to the subtree is re-assigned to its LHS, and a new ID is given
/// to its RHS. At the end of the walk, all leaf-level conditions will have a
/// unique ID -- keep in mind that the final set of IDs may not be in
/// numerical order from left to right.
///
/// Example: "x = (A && B) || (C && D) || (D && F)"
///
/// Visit Depth1:
/// (A && B) || (C && D) || (D && F)
/// ^-------LHS--------^ ^-RHS--^
/// ID=1 ID=2
///
/// Visit LHS-Depth2:
/// (A && B) || (C && D)
/// ^-LHS--^ ^-RHS--^
/// ID=1 ID=3
///
/// Visit LHS-Depth3:
/// (A && B)
/// LHS RHS
/// ID=1 ID=4
///
/// Visit RHS-Depth3:
/// (C && D)
/// LHS RHS
/// ID=3 ID=5
///
/// Visit RHS-Depth2: (D && F)
/// LHS RHS
/// ID=2 ID=6
///
/// Visit Depth1:
/// (A && B) || (C && D) || (D && F)
/// ID=1 ID=4 ID=3 ID=5 ID=2 ID=6
///
/// A node ID of '0' always means MC/DC isn't being tracked.
///
/// As the AST walk proceeds recursively, the algorithm will also use stacks
/// to track the IDs of logical-AND and logical-OR operations on the RHS so
/// that it can be determined which nodes are executed next, depending on how
/// a LHS or RHS of a logical-AND or logical-OR is evaluated. This
/// information relies on the assigned IDs and are embedded within the
/// coverage region IDs of each branch region associated with a leaf-level
/// condition. This information helps the visualization tool reconstruct all
/// possible test vectors for the purposes of MC/DC analysis. if a "next" node
/// ID is '0', it means it's the end of the test vector. The following rules
/// are used:
///
/// For logical-AND ("LHS && RHS"):
/// - If LHS is TRUE, execution goes to the RHS node.
/// - If LHS is FALSE, execution goes to the LHS node of the next logical-OR.
/// If that does not exist, execution exits (ID == 0).
///
/// - If RHS is TRUE, execution goes to LHS node of the next logical-AND.
/// If that does not exist, execution exits (ID == 0).
/// - If RHS is FALSE, execution goes to the LHS node of the next logical-OR.
/// If that does not exist, execution exits (ID == 0).
///
/// For logical-OR ("LHS || RHS"):
/// - If LHS is TRUE, execution goes to the LHS node of the next logical-AND.
/// If that does not exist, execution exits (ID == 0).
/// - If LHS is FALSE, execution goes to the RHS node.
///
/// - If RHS is TRUE, execution goes to LHS node of the next logical-AND.
/// If that does not exist, execution exits (ID == 0).
/// - If RHS is FALSE, execution goes to the LHS node of the next logical-OR.
/// If that does not exist, execution exits (ID == 0).
///
/// Finally, the condition IDs are also used when instrumenting the code to
/// indicate a unique offset into a temporary bitmask that represents the true
/// or false evaluation of that particular condition.
private:
CodeGenModule &CGM;
std::stack<unsigned> AndRHS;
std::stack<unsigned> OrRHS;
std::stack<const BinaryOperator *> NestLevel;
llvm::DenseMap<const Stmt *, unsigned> &CondIDs;
llvm::DenseMap<const Stmt *, unsigned> &BitmaskMap;
unsigned NextID = 1;
bool NotMapped = false;
/// Is this a logical-AND operation?
bool isLAnd(const BinaryOperator *E) { return E->getOpcode() == BO_LAnd; }
peter.smithUnsubmitted
Not Done
ReplyInline Actions

Could this be a free function? If not then could it be const?

peter.smith: Could this be a free function? If not then could it be `const`?
/// Push an ID onto the corresponding RHS stack.
void pushRHS(const BinaryOperator *E) {
std::stack<unsigned> &rhs = isLAnd(E) ? AndRHS : OrRHS;
rhs.push(CondIDs[stripCond(E->getRHS())]);
}
/// Pop an ID from the corresponding RHS stack.
void popRHS(const BinaryOperator *E) {
std::stack<unsigned> &rhs = isLAnd(E) ? AndRHS : OrRHS;
if (!rhs.empty())
rhs.pop();
}
/// If the expected ID is on top, pop it off the corresponding RHS stack.
void popRHSifTop(const BinaryOperator *E) {
if (!OrRHS.empty() && CondIDs[(Expr *)E] == OrRHS.top())
OrRHS.pop();
else if (!AndRHS.empty() && CondIDs[(Expr *)E] == AndRHS.top())
AndRHS.pop();
}
/// Ignore parentheses and logical-NOT to track conditions consistently.
const Expr *stripCond(const Expr *C) {
if (const UnaryOperator *UnOp = dyn_cast<UnaryOperator>(C->IgnoreParens()))
if (UnOp->getOpcode() == UO_LNot)
C = UnOp->getSubExpr();
return C->IgnoreParens();
}
public:
MCDCCoverageBuilder(CodeGenModule &CGM,
llvm::DenseMap<const Stmt *, unsigned> &CondIDMap,
llvm::DenseMap<const Stmt *, unsigned> &BitmaskMap)
: CGM(CGM), CondIDs(CondIDMap), BitmaskMap(BitmaskMap) {}
/// Return the ID of the RHS of the next, upper nest-level logical-OR.
unsigned getNextLOrCondID() { return OrRHS.empty() ? 0 : OrRHS.top(); }
/// Return the ID of the RHS of the next, upper nest-level logical-AND.
unsigned getNextLAndCondID() { return AndRHS.empty() ? 0 : AndRHS.top(); }
/// Return the ID of a given condition.
unsigned getCondID(Expr *Cond) {
auto I = CondIDs.find(stripCond(Cond));
if (I == CondIDs.end())
return 0;
else
return I->second;
}
/// Push the binary operator statement to track the nest level and assign IDs
/// to the operator's LHS and RHS. The RHS may be a larger subtree that is
/// broken up on successive levels.
void pushAndAssignIDs(const BinaryOperator *E) {
if (CGM.getCodeGenOpts().MCDCCoverage) {
peter.smithUnsubmitted
Not Done
ReplyInline Actions

Would it be better to invert the condition and early exit? This would save a level of indentation for the rest of the function.

peter.smith: Would it be better to invert the condition and early exit? This would save a level of…
// If binary expression is disqualified, don't do mapping.
if (NestLevel.empty() &&
BitmaskMap.find(stripCond((Expr *)E)) == BitmaskMap.end())
NotMapped = true;
// Push Stmt on 'NestLevel' stack to keep track of nest location.
NestLevel.push(E);
// Don't go any further if we don't need to map condition IDs.
if (NotMapped)
return;
// If the operator itself has an assigned ID, this means it represents a
// larger subtree. In this case, pop its ID out of the RHS stack and
// assign that ID to its LHS node. Its RHS will receive a new ID.
if (CondIDs.find(stripCond((Expr *)E)) != CondIDs.end()) {
// If Stmt has an ID, assign its ID to LHS
CondIDs[stripCond(E->getLHS())] = CondIDs[(Expr *)E];
// Since the operator's LHS assumes the operator's same ID, pop the
// operator from the RHS stack so that if LHS short-circuits, it won't
// be incorrectly re-used as the node executed next.
popRHSifTop(E);
} else {
// Otherwise, assign ID+1 to LHS.
CondIDs[stripCond(E->getLHS())] = NextID++;
}
// Assign ID+1 to RHS.
CondIDs[stripCond(E->getRHS())] = NextID++;
// Push ID of Stmt's RHS so that LHS nodes know about it
pushRHS(E);
}
}
/// Pop the binary operator from the next level. If the walk is at the top of
/// the next, assign the total number of conditions.
unsigned popAndReturnCondCount(const BinaryOperator *E) {
unsigned TotalConds = 0;
if (CGM.getCodeGenOpts().MCDCCoverage) {
peter.smithUnsubmitted
Not Done
ReplyInline Actions

Would it be better to invert the condition and early exit? This would save a level of indentation for the rest of the function.

peter.smith: Would it be better to invert the condition and early exit? This would save a level of…
// Pop Stmt from 'NestLevel' stack.
assert(NestLevel.top() == E);
NestLevel.pop();
// Reset state if not doing mapping.
if (NestLevel.empty() && NotMapped) {
NotMapped = false;
return 0;
}
// Pop RHS ID.
popRHS(E);
// If at the parent (NestLevel=0), set conds and reset.
if (NestLevel.empty()) {
TotalConds = NextID - 1;
// Reset ID back to beginning.
NextID = 1;
}
}
return TotalConds;
}
};
/// A StmtVisitor that creates coverage mapping regions which map /// A StmtVisitor that creates coverage mapping regions which map
/// from the source code locations to the PGO counters. /// from the source code locations to the PGO counters.
struct CounterCoverageMappingBuilder struct CounterCoverageMappingBuilder
: public CoverageMappingBuilder, : public CoverageMappingBuilder,
public ConstStmtVisitor<CounterCoverageMappingBuilder> { public ConstStmtVisitor<CounterCoverageMappingBuilder> {
/// The map of statements to count values. /// The map of statements to count values.
llvm::DenseMap<const Stmt *, unsigned> &CounterMap; llvm::DenseMap<const Stmt *, unsigned> &CounterMap;
/// The map of statements to bitmask coverage object values.
llvm::DenseMap<const Stmt *, unsigned> &BitmaskMap;
/// A stack of currently live regions. /// A stack of currently live regions.
std::vector<SourceMappingRegion> RegionStack; std::vector<SourceMappingRegion> RegionStack;
/// An object to manage MCDC regions.
MCDCCoverageBuilder MCDCBuilder;
CounterExpressionBuilder Builder; CounterExpressionBuilder Builder;
/// A location in the most recently visited file or macro. /// A location in the most recently visited file or macro.
/// ///
/// This is used to adjust the active source regions appropriately when /// This is used to adjust the active source regions appropriately when
/// expressions cross file or macro boundaries. /// expressions cross file or macro boundaries.
SourceLocation MostRecentLocation; SourceLocation MostRecentLocation;
Show All 20 Linesstruct CounterCoverageMappingBuilder
/// Return the region counter for the given statement. /// Return the region counter for the given statement.
/// ///
/// This should only be called on statements that have a dedicated counter. /// This should only be called on statements that have a dedicated counter.
Counter getRegionCounter(const Stmt *S) { Counter getRegionCounter(const Stmt *S) {
return Counter::getCounter(CounterMap[S]); return Counter::getCounter(CounterMap[S]);
} }
unsigned getRegionBitmask(const Stmt *S) { return BitmaskMap[S]; }
/// Push a region onto the stack. /// Push a region onto the stack.
/// ///
/// Returns the index on the stack where the region was pushed. This can be /// Returns the index on the stack where the region was pushed. This can be
/// used with popRegions to exit a "scope", ending the region that was pushed. /// used with popRegions to exit a "scope", ending the region that was pushed.
size_t pushRegion(Counter Count, Optional<SourceLocation> StartLoc = None, size_t pushRegion(Counter Count, Optional<SourceLocation> StartLoc = None,
Optional<SourceLocation> EndLoc = None, Optional<SourceLocation> EndLoc = None,
Optional<Counter> FalseCount = None) { Optional<Counter> FalseCount = None, unsigned ID = 0,
unsigned TrueID = 0, unsigned FalseID = 0) {
if (StartLoc && !FalseCount) { if (StartLoc && !FalseCount) {
MostRecentLocation = *StartLoc; MostRecentLocation = *StartLoc;
} }
RegionStack.emplace_back(Count, FalseCount, StartLoc, EndLoc); RegionStack.emplace_back(Count, FalseCount, ID, TrueID, FalseID, StartLoc,
EndLoc);
return RegionStack.size() - 1;
}
size_t pushRegion(unsigned Mask, unsigned Conditions,
Optional<SourceLocation> StartLoc = None,
Optional<SourceLocation> EndLoc = None) {
RegionStack.emplace_back(Mask, Conditions, StartLoc, EndLoc);
return RegionStack.size() - 1; return RegionStack.size() - 1;
} }
size_t locationDepth(SourceLocation Loc) { size_t locationDepth(SourceLocation Loc) {
size_t Depth = 0; size_t Depth = 0;
while (Loc.isValid()) { while (Loc.isValid()) {
Loc = getIncludeOrExpansionLoc(Loc); Loc = getIncludeOrExpansionLoc(Loc);
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines bool ConditionFoldsToBool(const Expr *Cond) {
Expr::EvalResult Result; Expr::EvalResult Result;
return (Cond->EvaluateAsInt(Result, CVM.getCodeGenModule().getContext())); return (Cond->EvaluateAsInt(Result, CVM.getCodeGenModule().getContext()));
} }
/// Create a Branch Region around an instrumentable condition for coverage /// Create a Branch Region around an instrumentable condition for coverage
/// and add it to the function's SourceRegions. A branch region tracks a /// and add it to the function's SourceRegions. A branch region tracks a
/// "True" counter and a "False" counter for boolean expressions that /// "True" counter and a "False" counter for boolean expressions that
/// result in the generation of a branch. /// result in the generation of a branch.
void createBranchRegion(const Expr *C, Counter TrueCnt, Counter FalseCnt) { void createBranchRegion(const Expr *C, Counter TrueCnt, Counter FalseCnt,
unsigned ID = 0, unsigned TrueID = 0,
unsigned FalseID = 0) {
// Check for NULL conditions. // Check for NULL conditions.
if (!C) if (!C)
return; return;
// Ensure we are an instrumentable condition (i.e. no "&&" or "||"). Push // Ensure we are an instrumentable condition (i.e. no "&&" or "||"). Push
// region onto RegionStack but immediately pop it (which adds it to the // region onto RegionStack but immediately pop it (which adds it to the
// function's SourceRegions) because it doesn't apply to any other source // function's SourceRegions) because it doesn't apply to any other source
// code other than the Condition. // code other than the Condition.
if (CodeGenFunction::isInstrumentedCondition(C)) { if (CodeGenFunction::isInstrumentedCondition(C)) {
// If a condition can fold to true or false, the corresponding branch // If a condition can fold to true or false, the corresponding branch
// will be removed. Create a region with both counters hard-coded to // will be removed. Create a region with both counters hard-coded to
// zero. This allows us to visualize them in a special way. // zero. This allows us to visualize them in a special way.
// Alternatively, we can prevent any optimization done via // Alternatively, we can prevent any optimization done via
// constant-folding by ensuring that ConstantFoldsToSimpleInteger() in // constant-folding by ensuring that ConstantFoldsToSimpleInteger() in
// CodeGenFunction.c always returns false, but that is very heavy-handed. // CodeGenFunction.c always returns false, but that is very heavy-handed.
if (ConditionFoldsToBool(C)) if (ConditionFoldsToBool(C))
popRegions(pushRegion(Counter::getZero(), getStart(C), getEnd(C), popRegions(pushRegion(Counter::getZero(), getStart(C), getEnd(C),
Counter::getZero())); Counter::getZero(), ID, TrueID, FalseID));
else else
// Otherwise, create a region with the True counter and False counter. // Otherwise, create a region with the True counter and False counter.
popRegions(pushRegion(TrueCnt, getStart(C), getEnd(C), FalseCnt)); popRegions(pushRegion(TrueCnt, getStart(C), getEnd(C), FalseCnt, ID,
TrueID, FalseID));
} }
} }
/// Create a Decision Region with a Mask ID and number of Conditions. This
/// type of region "contains" branch regions, one for each of the conditions.
/// The visualization tool will group everything together.
void createDecisionRegion(const Expr *C, unsigned Mask, unsigned Conditions) {
popRegions(pushRegion(Mask, Conditions, getStart(C), getEnd(C)));
}
/// Create a Branch Region around a SwitchCase for code coverage /// Create a Branch Region around a SwitchCase for code coverage
/// and add it to the function's SourceRegions. /// and add it to the function's SourceRegions.
void createSwitchCaseRegion(const SwitchCase *SC, Counter TrueCnt, void createSwitchCaseRegion(const SwitchCase *SC, Counter TrueCnt,
Counter FalseCnt) { Counter FalseCnt) {
// Push region onto RegionStack but immediately pop it (which adds it to // Push region onto RegionStack but immediately pop it (which adds it to
// the function's SourceRegions) because it doesn't apply to any other // the function's SourceRegions) because it doesn't apply to any other
// source other than the SwitchCase. // source other than the SwitchCase.
popRegions(pushRegion(TrueCnt, getStart(SC), SC->getColonLoc(), FalseCnt)); popRegions(pushRegion(TrueCnt, getStart(SC), SC->getColonLoc(), FalseCnt));
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines for (SourceMappingRegion &I : llvm::reverse(RegionStack)) {
} }
while (!SM.isInFileID(Loc, ParentFile)) { while (!SM.isInFileID(Loc, ParentFile)) {
// The most nested region for each start location is the one with the // The most nested region for each start location is the one with the
// correct count. We avoid creating redundant regions by stopping once // correct count. We avoid creating redundant regions by stopping once
// we've seen this region. // we've seen this region.
if (StartLocs.insert(Loc).second) { if (StartLocs.insert(Loc).second) {
if (I.isBranch()) if (I.isBranch())
SourceRegions.emplace_back(I.getCounter(), I.getFalseCounter(), Loc, SourceRegions.emplace_back(
getEndOfFileOrMacro(Loc), I.isBranch()); I.getCounter(), I.getFalseCounter(), I.getID(), I.getTrueID(),
I.getFalseID(), Loc, getEndOfFileOrMacro(Loc), I.isBranch());
else else
SourceRegions.emplace_back(I.getCounter(), Loc, SourceRegions.emplace_back(I.getCounter(), Loc,
getEndOfFileOrMacro(Loc)); getEndOfFileOrMacro(Loc));
} }
Loc = getIncludeOrExpansionLoc(Loc); Loc = getIncludeOrExpansionLoc(Loc);
} }
I.setStartLoc(getPreciseTokenLocEnd(Loc)); I.setStartLoc(getPreciseTokenLocEnd(Loc));
} }
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Linesstruct CounterCoverageMappingBuilder
struct BreakContinue { struct BreakContinue {
Counter BreakCount; Counter BreakCount;
Counter ContinueCount; Counter ContinueCount;
}; };
SmallVector<BreakContinue, 8> BreakContinueStack; SmallVector<BreakContinue, 8> BreakContinueStack;
CounterCoverageMappingBuilder( CounterCoverageMappingBuilder(
CoverageMappingModuleGen &CVM, CoverageMappingModuleGen &CVM,
llvm::DenseMap<const Stmt *, unsigned> &CounterMap, SourceManager &SM, llvm::DenseMap<const Stmt *, unsigned> &CounterMap,
llvm::DenseMap<const Stmt *, unsigned> &BitmaskMap,
llvm::DenseMap<const Stmt *, unsigned> &CondIDMap, SourceManager &SM,
const LangOptions &LangOpts) const LangOptions &LangOpts)
: CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap) {} : CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap),
BitmaskMap(BitmaskMap),
MCDCBuilder(CVM.getCodeGenModule(), CondIDMap, BitmaskMap) {}
/// Write the mapping data to the output stream /// Write the mapping data to the output stream
void write(llvm::raw_ostream &OS) { void write(llvm::raw_ostream &OS) {
llvm::SmallVector<unsigned, 8> VirtualFileMapping; llvm::SmallVector<unsigned, 8> VirtualFileMapping;
gatherFileIDs(VirtualFileMapping); gatherFileIDs(VirtualFileMapping);
SourceRegionFilter Filter = emitExpansionRegions(); SourceRegionFilter Filter = emitExpansionRegions();
emitSourceRegions(Filter); emitSourceRegions(Filter);
gatherSkippedRegions(); gatherSkippedRegions();
▲ Show 20 Lines • Show All 510 Lines • ▼ Show 20 Lines propagateCounts(subtractCounters(ParentCount, TrueCount),
E->getFalseExpr()); E->getFalseExpr());
// Create Branch Region around condition. // Create Branch Region around condition.
createBranchRegion(E->getCond(), TrueCount, createBranchRegion(E->getCond(), TrueCount,
subtractCounters(ParentCount, TrueCount)); subtractCounters(ParentCount, TrueCount));
} }
void VisitBinLAnd(const BinaryOperator *E) { void VisitBinLAnd(const BinaryOperator *E) {
// Keep track of Binary Operator and assign MCDC condition IDs
MCDCBuilder.pushAndAssignIDs(E);
extendRegion(E->getLHS()); extendRegion(E->getLHS());
propagateCounts(getRegion().getCounter(), E->getLHS()); propagateCounts(getRegion().getCounter(), E->getLHS());
handleFileExit(getEnd(E->getLHS())); handleFileExit(getEnd(E->getLHS()));
// Counter tracks the right hand side of a logical and operator. // Counter tracks the right hand side of a logical and operator.
extendRegion(E->getRHS()); extendRegion(E->getRHS());
propagateCounts(getRegionCounter(E), E->getRHS()); propagateCounts(getRegionCounter(E), E->getRHS());
// Process Binary Operator and create MCDC Decision Region if top-level
unsigned NumConds = 0;
if ((NumConds = MCDCBuilder.popAndReturnCondCount(E)))
createDecisionRegion(E, getRegionBitmask(E), NumConds);
// Extract the RHS's Execution Counter. // Extract the RHS's Execution Counter.
Counter RHSExecCnt = getRegionCounter(E); Counter RHSExecCnt = getRegionCounter(E);
// Extract the RHS's "True" Instance Counter. // Extract the RHS's "True" Instance Counter.
Counter RHSTrueCnt = getRegionCounter(E->getRHS()); Counter RHSTrueCnt = getRegionCounter(E->getRHS());
// Extract the Parent Region Counter. // Extract the Parent Region Counter.
Counter ParentCnt = getRegion().getCounter(); Counter ParentCnt = getRegion().getCounter();
// Extract the MCDC condition IDs (returns 0 if not needed).
unsigned NextOrID = MCDCBuilder.getNextLOrCondID();
unsigned NextAndID = MCDCBuilder.getNextLAndCondID();
unsigned LHSid = MCDCBuilder.getCondID(E->getLHS());
unsigned RHSid = MCDCBuilder.getCondID(E->getRHS());
// Create Branch Region around LHS condition. // Create Branch Region around LHS condition.
// MC/DC: For "LHS && RHS"
// - If LHS is TRUE, execution goes to the RHS.
// - If LHS is FALSE, execution goes to the LHS of the next logical-OR.
// If that does not exist, execution exits (ID == 0).
createBranchRegion(E->getLHS(), RHSExecCnt, createBranchRegion(E->getLHS(), RHSExecCnt,
subtractCounters(ParentCnt, RHSExecCnt)); subtractCounters(ParentCnt, RHSExecCnt), LHSid, RHSid,
NextOrID);
// Create Branch Region around RHS condition. // Create Branch Region around RHS condition.
// MC/DC: For "LHS && RHS"
// - If RHS is TRUE, execution goes to LHS of the next logical-AND.
// If that does not exist, execution exits (ID == 0).
// - If RHS is FALSE, execution goes to the LHS of the next logical-OR.
// If that does not exist, execution exits (ID == 0).
createBranchRegion(E->getRHS(), RHSTrueCnt, createBranchRegion(E->getRHS(), RHSTrueCnt,
subtractCounters(RHSExecCnt, RHSTrueCnt)); subtractCounters(RHSExecCnt, RHSTrueCnt), RHSid,
NextAndID, NextOrID);
} }
void VisitBinLOr(const BinaryOperator *E) { void VisitBinLOr(const BinaryOperator *E) {
// Keep track of Binary Operator and assign MCDC condition IDs
MCDCBuilder.pushAndAssignIDs(E);
extendRegion(E->getLHS()); extendRegion(E->getLHS());
propagateCounts(getRegion().getCounter(), E->getLHS()); propagateCounts(getRegion().getCounter(), E->getLHS());
handleFileExit(getEnd(E->getLHS())); handleFileExit(getEnd(E->getLHS()));
// Counter tracks the right hand side of a logical or operator. // Counter tracks the right hand side of a logical or operator.
extendRegion(E->getRHS()); extendRegion(E->getRHS());
propagateCounts(getRegionCounter(E), E->getRHS()); propagateCounts(getRegionCounter(E), E->getRHS());
// Process Binary Operator and create MCDC Decision Region if top-level
unsigned NumConds = 0;
if ((NumConds = MCDCBuilder.popAndReturnCondCount(E)))
createDecisionRegion(E, getRegionBitmask(E), NumConds);
// Extract the RHS's Execution Counter. // Extract the RHS's Execution Counter.
Counter RHSExecCnt = getRegionCounter(E); Counter RHSExecCnt = getRegionCounter(E);
// Extract the RHS's "False" Instance Counter. // Extract the RHS's "False" Instance Counter.
Counter RHSFalseCnt = getRegionCounter(E->getRHS()); Counter RHSFalseCnt = getRegionCounter(E->getRHS());
// Extract the Parent Region Counter. // Extract the Parent Region Counter.
Counter ParentCnt = getRegion().getCounter(); Counter ParentCnt = getRegion().getCounter();
// Extract the MCDC condition IDs (returns 0 if not needed).
unsigned NextOrID = MCDCBuilder.getNextLOrCondID();
unsigned NextAndID = MCDCBuilder.getNextLAndCondID();
unsigned LHSid = MCDCBuilder.getCondID(E->getLHS());
unsigned RHSid = MCDCBuilder.getCondID(E->getRHS());
// Create Branch Region around LHS condition. // Create Branch Region around LHS condition.
// MC/DC: For "LHS || RHS"
// - If LHS is TRUE, execution goes to the LHS of the next logical-AND.
// If that does not exist, execution exits (ID == 0).
// - If LHS is FALSE, execution goes to the RHS.
createBranchRegion(E->getLHS(), subtractCounters(ParentCnt, RHSExecCnt), createBranchRegion(E->getLHS(), subtractCounters(ParentCnt, RHSExecCnt),
RHSExecCnt); RHSExecCnt, LHSid, NextAndID, RHSid);
// Create Branch Region around RHS condition. // Create Branch Region around RHS condition.
// MC/DC: For "LHS || RHS"
// - If RHS is TRUE, execution goes to LHS of the next logical-AND.
// If that does not exist, execution exits (ID == 0).
// - If RHS is FALSE, execution goes to the LHS of the next logical-OR.
// If that does not exist, execution exits (ID == 0).
createBranchRegion(E->getRHS(), subtractCounters(RHSExecCnt, RHSFalseCnt), createBranchRegion(E->getRHS(), subtractCounters(RHSExecCnt, RHSFalseCnt),
RHSFalseCnt); RHSFalseCnt, RHSid, NextAndID, NextOrID);
} }
void VisitLambdaExpr(const LambdaExpr *LE) { void VisitLambdaExpr(const LambdaExpr *LE) {
// Lambdas are treated as their own functions for now, so we shouldn't // Lambdas are treated as their own functions for now, so we shouldn't
// propagate counts into them. // propagate counts into them.
} }
}; };
Show All 14 Lines case CounterMappingRegion::ExpansionRegion:
break; break;
case CounterMappingRegion::SkippedRegion: case CounterMappingRegion::SkippedRegion:
OS << "Skipped,"; OS << "Skipped,";
break; break;
case CounterMappingRegion::GapRegion: case CounterMappingRegion::GapRegion:
OS << "Gap,"; OS << "Gap,";
break; break;
case CounterMappingRegion::BranchRegion: case CounterMappingRegion::BranchRegion:
case CounterMappingRegion::MCDCBranchRegion:
OS << "Branch,"; OS << "Branch,";
break; break;
case CounterMappingRegion::MCDCDecisionRegion:
OS << "Decision,";
break;
} }
OS << "File " << R.FileID << ", " << R.LineStart << ":" << R.ColumnStart OS << "File " << R.FileID << ", " << R.LineStart << ":" << R.ColumnStart
<< " -> " << R.LineEnd << ":" << R.ColumnEnd << " = "; << " -> " << R.LineEnd << ":" << R.ColumnEnd << " = ";
if (R.Kind == CounterMappingRegion::MCDCDecisionRegion) {
OS << "M:" << R.Mask << ", C:" << R.NumConditions;
} else {
Ctx.dump(R.Count, OS); Ctx.dump(R.Count, OS);
if (R.Kind == CounterMappingRegion::BranchRegion) { if (R.Kind == CounterMappingRegion::BranchRegion ||
R.Kind == CounterMappingRegion::MCDCBranchRegion) {
OS << ", "; OS << ", ";
Ctx.dump(R.FalseCount, OS); Ctx.dump(R.FalseCount, OS);
} }
}
if (R.Kind == CounterMappingRegion::MCDCBranchRegion)
OS << " [" << R.ID << "," << R.TrueID << "," << R.FalseID << "] ";
if (R.Kind == CounterMappingRegion::ExpansionRegion) if (R.Kind == CounterMappingRegion::ExpansionRegion)
OS << " (Expanded file = " << R.ExpandedFileID << ")"; OS << " (Expanded file = " << R.ExpandedFileID << ")";
OS << "\n"; OS << "\n";
} }
} }
CoverageMappingModuleGen::CoverageMappingModuleGen( CoverageMappingModuleGen::CoverageMappingModuleGen(
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lines if (It != FileEntries.end())
return It->second; return It->second;
unsigned FileID = FileEntries.size() + 1; unsigned FileID = FileEntries.size() + 1;
FileEntries.insert(std::make_pair(File, FileID)); FileEntries.insert(std::make_pair(File, FileID));
return FileID; return FileID;
} }
void CoverageMappingGen::emitCounterMapping(const Decl *D, void CoverageMappingGen::emitCounterMapping(const Decl *D,
llvm::raw_ostream &OS) { llvm::raw_ostream &OS) {
assert(CounterMap); assert(CounterMap && BitmaskMap);
CounterCoverageMappingBuilder Walker(CVM, *CounterMap, SM, LangOpts); CounterCoverageMappingBuilder Walker(CVM, *CounterMap, *BitmaskMap,
*CondIDMap, SM, LangOpts);
Walker.VisitDecl(D); Walker.VisitDecl(D);
Walker.write(OS); Walker.write(OS);
} }
void CoverageMappingGen::emitEmptyMapping(const Decl *D, void CoverageMappingGen::emitEmptyMapping(const Decl *D,
llvm::raw_ostream &OS) { llvm::raw_ostream &OS) {
EmptyCoverageMappingBuilder Walker(CVM, SM, LangOpts); EmptyCoverageMappingBuilder Walker(CVM, SM, LangOpts);
Walker.VisitDecl(D); Walker.VisitDecl(D);
Walker.write(OS); Walker.write(OS);
} }

clang/lib/Driver/ToolChains/Clang.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 901 Lines • ▼ Show 20 Lines bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
options::OPT_fno_test_coverage, false) || options::OPT_fno_test_coverage, false) ||
Args.hasArg(options::OPT_coverage); Args.hasArg(options::OPT_coverage);
bool EmitCovData = TC.needsGCovInstrumentation(Args); bool EmitCovData = TC.needsGCovInstrumentation(Args);
if (EmitCovNotes) if (EmitCovNotes)
CmdArgs.push_back("-ftest-coverage"); CmdArgs.push_back("-ftest-coverage");
if (EmitCovData) if (EmitCovData)
CmdArgs.push_back("-fprofile-arcs"); CmdArgs.push_back("-fprofile-arcs");
bool CoverageMapping = false;
if (Args.hasFlag(options::OPT_fcoverage_mapping, if (Args.hasFlag(options::OPT_fcoverage_mapping,
options::OPT_fno_coverage_mapping, false)) { options::OPT_fno_coverage_mapping, false)) {
if (!ProfileGenerateArg) if (!ProfileGenerateArg)
D.Diag(clang::diag::err_drv_argument_only_allowed_with) D.Diag(clang::diag::err_drv_argument_only_allowed_with)
<< "-fcoverage-mapping" << "-fcoverage-mapping"
<< "-fprofile-instr-generate"; << "-fprofile-instr-generate";
CmdArgs.push_back("-fcoverage-mapping"); CmdArgs.push_back("-fcoverage-mapping");
CoverageMapping = true;
}
if (Args.hasFlag(options::OPT_fmcdc_coverage, options::OPT_fno_mcdc_coverage,
false)) {
if (!CoverageMapping)
peter.smithUnsubmitted
Not Done
ReplyInline Actions

Maybe able to simplify this to if (Args.hasFlag(options::OPT_fcoverage_mapping) and remove CoverageMapping. I think that in the case of !ProfileGenerateArg there are several options so it needed to be a variable.

peter.smith: Maybe able to simplify this to `if (Args.hasFlag(options::OPT_fcoverage_mapping)` and remove…
D.Diag(clang::diag::err_drv_argument_only_allowed_with)
<< "-fmcdc"
<< "-fcoverage-mapping";
CmdArgs.push_back("-fmcdc");
} }
if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ, if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
options::OPT_fcoverage_compilation_dir_EQ)) { options::OPT_fcoverage_compilation_dir_EQ)) {
if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ)) if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
CmdArgs.push_back(Args.MakeArgString( CmdArgs.push_back(Args.MakeArgString(
Twine("-fcoverage-compilation-dir=") + A->getValue())); Twine("-fcoverage-compilation-dir=") + A->getValue()));
else else
▲ Show 20 Lines • Show All 7,587 Lines • Show Last 20 Lines

clang/lib/Driver/ToolChains/Darwin.cpp

Show First 20 Lines • Show All 1,359 Lines • ▼ Show 20 Lines if (ForGCOV) {
addExportedSymbol(CmdArgs, "_writeout_fn_list"); addExportedSymbol(CmdArgs, "_writeout_fn_list");
addExportedSymbol(CmdArgs, "_reset_fn_list"); addExportedSymbol(CmdArgs, "_reset_fn_list");
} else { } else {
addExportedSymbol(CmdArgs, "___llvm_profile_filename"); addExportedSymbol(CmdArgs, "___llvm_profile_filename");
addExportedSymbol(CmdArgs, "___llvm_profile_raw_version"); addExportedSymbol(CmdArgs, "___llvm_profile_raw_version");
} }
} }
// Align __llvm_prf_{cnts,data} sections to the maximum expected page // Align __llvm_prf_{cnts,bitmask,data} sections to the maximum expected page
// alignment. This allows profile counters to be mmap()'d to disk. Note that // alignment. This allows profile counters to be mmap()'d to disk. Note that
// it's not enough to just page-align __llvm_prf_cnts: the following section // it's not enough to just page-align __llvm_prf_cnts: the following section
// must also be page-aligned so that its data is not clobbered by mmap(). // must also be page-aligned so that its data is not clobbered by mmap().
// //
// The section alignment is only needed when continuous profile sync is // The section alignment is only needed when continuous profile sync is
// enabled, but this is expected to be the default in Xcode. Specifying the // enabled, but this is expected to be the default in Xcode. Specifying the
// extra alignment also allows the same binary to be used with/without sync // extra alignment also allows the same binary to be used with/without sync
// enabled. // enabled.
if (!ForGCOV) { if (!ForGCOV) {
for (auto IPSK : {llvm::IPSK_cnts, llvm::IPSK_data}) { for (auto IPSK : {llvm::IPSK_cnts, llvm::IPSK_bitmask, llvm::IPSK_data}) {
addSectalignToPage( addSectalignToPage(
Args, CmdArgs, "__DATA", Args, CmdArgs, "__DATA",
llvm::getInstrProfSectionName(IPSK, llvm::Triple::MachO, llvm::getInstrProfSectionName(IPSK, llvm::Triple::MachO,
/*AddSegmentInfo=*/false)); /*AddSegmentInfo=*/false));
} }
} }
} }
▲ Show 20 Lines • Show All 1,905 Lines • Show Last 20 Lines

clang/test/CoverageMapping/branch-constfolded.cpp

// Test that branch regions are not generated for constant-folded conditions. // Test that branch regions are not generated for constant-folded conditions.
// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name branch-constfolded.cpp %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name branch-constfolded.cpp %s | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fmcdc -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name branch-constfolded.cpp %s | FileCheck %s -check-prefix=MCDC
// CHECK-LABEL: _Z6fand_0b: // CHECK-LABEL: _Z6fand_0b:
bool fand_0(bool a) { bool fand_0(bool a) { // MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:20 = M:0, C:2
return false && a; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:15 = 0, 0 return false && a; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:15 = 0, 0
} // CHECK: Branch,File 0, [[@LINE-1]]:19 -> [[@LINE-1]]:20 = #2, (#1 - #2) } // CHECK: Branch,File 0, [[@LINE-1]]:19 -> [[@LINE-1]]:20 = #2, (#1 - #2)
// CHECK-LABEL: _Z6fand_1b: // CHECK-LABEL: _Z6fand_1b:
bool fand_1(bool a) { bool fand_1(bool a) { // MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:19 = M:0, C:2
return a && true; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = #1, (#0 - #1) return a && true; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = #1, (#0 - #1)
} // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:19 = 0, 0 } // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:19 = 0, 0
// CHECK-LABEL: _Z6fand_2bb: // CHECK-LABEL: _Z6fand_2bb:
bool fand_2(bool a, bool b) { bool fand_2(bool a, bool b) {// MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:25 = M:0, C:3
return false && a && b; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:15 = 0, 0 return false && a && b; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:15 = 0, 0
} // CHECK: Branch,File 0, [[@LINE-1]]:19 -> [[@LINE-1]]:20 = #4, (#3 - #4) } // CHECK: Branch,File 0, [[@LINE-1]]:19 -> [[@LINE-1]]:20 = #4, (#3 - #4)
// CHECK: Branch,File 0, [[@LINE-2]]:24 -> [[@LINE-2]]:25 = #2, (#1 - #2) // CHECK: Branch,File 0, [[@LINE-2]]:24 -> [[@LINE-2]]:25 = #2, (#1 - #2)
// CHECK-LABEL: _Z6fand_3bb: // CHECK-LABEL: _Z6fand_3bb:
bool fand_3(bool a, bool b) { bool fand_3(bool a, bool b) {// MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:24 = M:0, C:3
return a && true && b; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = #3, (#0 - #3) return a && true && b; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = #3, (#0 - #3)
} // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:19 = 0, 0 } // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:19 = 0, 0
// CHECK: Branch,File 0, [[@LINE-2]]:23 -> [[@LINE-2]]:24 = #2, (#1 - #2) // CHECK: Branch,File 0, [[@LINE-2]]:23 -> [[@LINE-2]]:24 = #2, (#1 - #2)
// CHECK-LABEL: _Z6fand_4bb: // CHECK-LABEL: _Z6fand_4bb:
bool fand_4(bool a, bool b) { bool fand_4(bool a, bool b) {// MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:25 = M:0, C:3
return a && b && false; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = #3, (#0 - #3) return a && b && false; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = #3, (#0 - #3)
} // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:16 = #4, (#3 - #4) } // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:16 = #4, (#3 - #4)
// CHECK: Branch,File 0, [[@LINE-2]]:20 -> [[@LINE-2]]:25 = 0, 0 // CHECK: Branch,File 0, [[@LINE-2]]:20 -> [[@LINE-2]]:25 = 0, 0
// CHECK-LABEL: _Z6fand_5b: // CHECK-LABEL: _Z6fand_5b:
bool fand_5(bool a) { bool fand_5(bool a) { // MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:23 = M:0, C:2
return false && true; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:15 = 0, 0 return false && true; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:15 = 0, 0
} // CHECK: Branch,File 0, [[@LINE-1]]:19 -> [[@LINE-1]]:23 = 0, 0 } // CHECK: Branch,File 0, [[@LINE-1]]:19 -> [[@LINE-1]]:23 = 0, 0
// CHECK-LABEL: _Z6fand_6b: // CHECK-LABEL: _Z6fand_6b:
bool fand_6(bool a) { bool fand_6(bool a) { // MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:19 = M:0, C:2
return true && a; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:14 = 0, 0 return true && a; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:14 = 0, 0
} // CHECK: Branch,File 0, [[@LINE-1]]:18 -> [[@LINE-1]]:19 = #2, (#1 - #2) } // CHECK: Branch,File 0, [[@LINE-1]]:18 -> [[@LINE-1]]:19 = #2, (#1 - #2)
// CHECK-LABEL: _Z6fand_7b: // CHECK-LABEL: _Z6fand_7b:
bool fand_7(bool a) { bool fand_7(bool a) { // MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:20 = M:0, C:2
return a && false; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = #1, (#0 - #1) return a && false; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = #1, (#0 - #1)
} // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:20 = 0, 0 } // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:20 = 0, 0
// CHECK-LABEL: _Z5for_0b: // CHECK-LABEL: _Z5for_0b:
bool for_0(bool a) { bool for_0(bool a) { // MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:19 = M:0, C:2
return true || a; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:14 = 0, 0 return true || a; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:14 = 0, 0
} // CHECK: Branch,File 0, [[@LINE-1]]:18 -> [[@LINE-1]]:19 = (#1 - #2), #2 } // CHECK: Branch,File 0, [[@LINE-1]]:18 -> [[@LINE-1]]:19 = (#1 - #2), #2
// CHECK-LABEL: _Z5for_1b: // CHECK-LABEL: _Z5for_1b:
bool for_1(bool a) { bool for_1(bool a) { // MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:20 = M:0, C:2
return a || false; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = (#0 - #1), #1 return a || false; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = (#0 - #1), #1
} // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:20 = 0, 0 } // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:20 = 0, 0
// CHECK-LABEL: _Z5for_2bb: // CHECK-LABEL: _Z5for_2bb:
bool for_2(bool a, bool b) { bool for_2(bool a, bool b) {// MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:24 = M:0, C:3
return true || a || b; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:14 = 0, 0 return true || a || b; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:14 = 0, 0
} // CHECK: Branch,File 0, [[@LINE-1]]:18 -> [[@LINE-1]]:19 = (#3 - #4), #4 } // CHECK: Branch,File 0, [[@LINE-1]]:18 -> [[@LINE-1]]:19 = (#3 - #4), #4
// CHECK: Branch,File 0, [[@LINE-2]]:23 -> [[@LINE-2]]:24 = (#1 - #2), #2 // CHECK: Branch,File 0, [[@LINE-2]]:23 -> [[@LINE-2]]:24 = (#1 - #2), #2
// CHECK-LABEL: _Z5for_3bb: // CHECK-LABEL: _Z5for_3bb:
bool for_3(bool a, bool b) { bool for_3(bool a, bool b) {// MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:25 = M:0, C:3
return a || false || b; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = (#0 - #3), #3 return a || false || b; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = (#0 - #3), #3
} // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:20 = 0, 0 } // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:20 = 0, 0
// CHECK: Branch,File 0, [[@LINE-2]]:24 -> [[@LINE-2]]:25 = (#1 - #2), #2 // CHECK: Branch,File 0, [[@LINE-2]]:24 -> [[@LINE-2]]:25 = (#1 - #2), #2
// CHECK-LABEL: _Z5for_4bb: // CHECK-LABEL: _Z5for_4bb:
bool for_4(bool a, bool b) { bool for_4(bool a, bool b) {// MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:24 = M:0, C:3
return a || b || true; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = (#0 - #3), #3 return a || b || true; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = (#0 - #3), #3
} // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:16 = (#3 - #4), #4 } // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:16 = (#3 - #4), #4
// CHECK: Branch,File 0, [[@LINE-2]]:20 -> [[@LINE-2]]:24 = 0, 0 // CHECK: Branch,File 0, [[@LINE-2]]:20 -> [[@LINE-2]]:24 = 0, 0
// CHECK-LABEL: _Z5for_5b: // CHECK-LABEL: _Z5for_5b:
bool for_5(bool a) { bool for_5(bool a) { // MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:23 = M:0, C:2
return true || false; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:14 = 0, 0 return true || false; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:14 = 0, 0
} // CHECK: Branch,File 0, [[@LINE-1]]:18 -> [[@LINE-1]]:23 = 0, 0 } // CHECK: Branch,File 0, [[@LINE-1]]:18 -> [[@LINE-1]]:23 = 0, 0
// CHECK-LABEL: _Z5for_6b: // CHECK-LABEL: _Z5for_6b:
bool for_6(bool a) { bool for_6(bool a) { // MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:20 = M:0, C:2
return false || a; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:15 = 0, 0 return false || a; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:15 = 0, 0
} // CHECK: Branch,File 0, [[@LINE-1]]:19 -> [[@LINE-1]]:20 = (#1 - #2), #2 } // CHECK: Branch,File 0, [[@LINE-1]]:19 -> [[@LINE-1]]:20 = (#1 - #2), #2
// CHECK-LABEL: _Z5for_7b: // CHECK-LABEL: _Z5for_7b:
bool for_7(bool a) { bool for_7(bool a) { // MCDC: Decision,File 0, [[@LINE+1]]:10 -> [[@LINE+1]]:19 = M:0, C:2
return a || true; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = (#0 - #1), #1 return a || true; // CHECK: Branch,File 0, [[@LINE]]:10 -> [[@LINE]]:11 = (#0 - #1), #1
} // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:19 = 0, 0 } // CHECK: Branch,File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:19 = 0, 0

clang/test/CoverageMapping/branch-mincounters.cpp

// Test to ensure right number of counters are allocated and used for nested // Test to ensure right number of counters are allocated and used for nested
// logical operators on branch conditions for branch coverage. // logical operators on branch conditions for branch coverage.
// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name branch-logical-mixed.cpp %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name branch-logical-mixed.cpp %s | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fmcdc -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name branch-logical-mixed.cpp %s | FileCheck %s
// CHECK-LABEL: _Z5func1ii: // CHECK-LABEL: _Z5func1ii:
bool func1(int a, int b) { bool func1(int a, int b) {
bool b0 = a <= b; bool b0 = a <= b;
bool b1 = a == b; bool b1 = a == b;
bool b2 = a >= b; bool b2 = a >= b;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

clang/test/CoverageMapping/branch-templates.cpp

// Test that branch regions are generated for conditions in function template // Test that branch regions are generated for conditions in function template
// instantiations. // instantiations.
// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name branch-templates.cpp %s | FileCheck %s // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name branch-templates.cpp %s | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fmcdc -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name branch-templates.cpp %s | FileCheck %s
template<typename T> template<typename T>
void unused(T x) { void unused(T x) {
return; return;
} }
template<typename T> template<typename T>
int func(T x) { int func(T x) {
Show All 20 Lines

clang/test/CoverageMapping/if.cpp

// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -std=c++2b -triple %itanium_abi_triple -main-file-name if.cpp %s | FileCheck %s // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -std=c++2b -triple %itanium_abi_triple -main-file-name if.cpp %s | FileCheck %s
// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fmcdc -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -std=c++2b -triple %itanium_abi_triple -main-file-name if.cpp %s | FileCheck %s
int nop() { return 0; } int nop() { return 0; }
// CHECK-LABEL: _Z3foov: // CHECK-LABEL: _Z3foov:
// CHECK-NEXT: [[@LINE+3]]:12 -> [[@LINE+8]]:2 = #0 // CHECK-NEXT: [[@LINE+3]]:12 -> [[@LINE+8]]:2 = #0
// CHECK-NEXT: [[@LINE+3]]:15 -> [[@LINE+3]]:19 = #0 // CHECK-NEXT: [[@LINE+3]]:15 -> [[@LINE+3]]:19 = #0
// CHECK-NEXT: Branch,File 0, [[@LINE+2]]:15 -> [[@LINE+2]]:19 = 0, 0 // CHECK-NEXT: Branch,File 0, [[@LINE+2]]:15 -> [[@LINE+2]]:19 = 0, 0
void foo() { // CHECK-NEXT: Gap,File 0, [[@LINE+1]]:21 -> [[@LINE+1]]:22 = #2 void foo() { // CHECK-NEXT: Gap,File 0, [[@LINE+1]]:21 -> [[@LINE+1]]:22 = #2
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

clang/test/CoverageMapping/logical.cpp

// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name logical.cpp %s | FileCheck %s // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name logical.cpp %s | FileCheck %s
// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fmcdc -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name logical.cpp %s | FileCheck %s -check-prefix=MCDC
int main() { // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+22]]:2 = #0 int main() { // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+23]]:2 = #0
bool bt = true; bool bt = true;
bool bf = false; bool bf = false; // MCDC: Decision,File 0, [[@LINE+1]]:12 -> [[@LINE+1]]:20 = M:0, C:2
bool a = bt && bf; // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE]]:14 = #0 bool a = bt && bf; // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE]]:14 = #0
// CHECK-NEXT: Branch,File 0, [[@LINE-1]]:12 -> [[@LINE-1]]:14 = #1, (#0 - #1) // CHECK-NEXT: Branch,File 0, [[@LINE-1]]:12 -> [[@LINE-1]]:14 = #1, (#0 - #1)
// CHECK-NEXT: File 0, [[@LINE-2]]:18 -> [[@LINE-2]]:20 = #1 // CHECK-NEXT: File 0, [[@LINE-2]]:18 -> [[@LINE-2]]:20 = #1
// CHECK-NEXT: Branch,File 0, [[@LINE-3]]:18 -> [[@LINE-3]]:20 = #2, (#1 - #2) // CHECK-NEXT: Branch,File 0, [[@LINE-3]]:18 -> [[@LINE-3]]:20 = #2, (#1 - #2)
// MCDC: Decision,File 0, [[@LINE+1]]:7 -> [[@LINE+2]]:9 = M:1, C:2
a = bt && // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:9 = #0 a = bt && // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:9 = #0
bf; // CHECK-NEXT: Branch,File 0, [[@LINE-1]]:7 -> [[@LINE-1]]:9 = #3, (#0 - #3) bf; // CHECK-NEXT: Branch,File 0, [[@LINE-1]]:7 -> [[@LINE-1]]:9 = #3, (#0 - #3)
// CHECK-NEXT: File 0, [[@LINE-1]]:7 -> [[@LINE-1]]:9 = #3 // CHECK-NEXT: File 0, [[@LINE-1]]:7 -> [[@LINE-1]]:9 = #3
// CHECK-NEXT: Branch,File 0, [[@LINE-2]]:7 -> [[@LINE-2]]:9 = #4, (#3 - #4) // CHECK-NEXT: Branch,File 0, [[@LINE-2]]:7 -> [[@LINE-2]]:9 = #4, (#3 - #4)
// MCDC: Decision,File 0, [[@LINE+1]]:7 -> [[@LINE+1]]:15 = M:2, C:2
a = bf || bt; // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:9 = #0 a = bf || bt; // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:9 = #0
// CHECK-NEXT: Branch,File 0, [[@LINE-1]]:7 -> [[@LINE-1]]:9 = (#0 - #5), #5 // CHECK-NEXT: Branch,File 0, [[@LINE-1]]:7 -> [[@LINE-1]]:9 = (#0 - #5), #5
// CHECK-NEXT: File 0, [[@LINE-2]]:13 -> [[@LINE-2]]:15 = #5 // CHECK-NEXT: File 0, [[@LINE-2]]:13 -> [[@LINE-2]]:15 = #5
// CHECK-NEXT: Branch,File 0, [[@LINE-3]]:13 -> [[@LINE-3]]:15 = (#5 - #6), #6 // CHECK-NEXT: Branch,File 0, [[@LINE-3]]:13 -> [[@LINE-3]]:15 = (#5 - #6), #6
// MCDC: Decision,File 0, [[@LINE+1]]:7 -> [[@LINE+2]]:9 = M:3, C:2
a = bf || // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:9 = #0 a = bf || // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:9 = #0
bt; // CHECK-NEXT: Branch,File 0, [[@LINE-1]]:7 -> [[@LINE-1]]:9 = (#0 - #7), #7 bt; // CHECK-NEXT: Branch,File 0, [[@LINE-1]]:7 -> [[@LINE-1]]:9 = (#0 - #7), #7
// CHECK-NEXT: File 0, [[@LINE-1]]:7 -> [[@LINE-1]]:9 = #7 // CHECK-NEXT: File 0, [[@LINE-1]]:7 -> [[@LINE-1]]:9 = #7
// CHECK-NEXT: Branch,File 0, [[@LINE-2]]:7 -> [[@LINE-2]]:9 = (#7 - #8), #8 // CHECK-NEXT: Branch,File 0, [[@LINE-2]]:7 -> [[@LINE-2]]:9 = (#7 - #8), #8
return 0; return 0;
} }

clang/test/CoverageMapping/mcdc-error-conditions.cpp

  • This file was added.
// RUN: not %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fmcdc -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only %s 2>&1| FileCheck %s
bool func_conditions(bool a, bool b, bool c, bool d, bool e, bool f, bool g) {
return a && b && c && d && e && f && g;
}
// CHECK: error: MC/DC: Unsupported boolean expression; number of conditions{{.*}} exceeds max

clang/test/CoverageMapping/mcdc-error-nests.cpp

  • This file was added.
// RUN: not %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fmcdc -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only %s 2>&1| FileCheck %s
// "Split-nest" -- boolean expressions within boolean expressions.
extern bool bar(bool);
bool func_split_nest(bool a, bool b, bool c, bool d, bool e, bool f, bool g) {
bool res = a && b && c && bar(d && e) && f && g;
return bar(res);
}
// CHECK: error: MC/DC: Unsupported boolean expression; contains an operation with a nested boolean expression.

clang/test/CoverageMapping/mcdc-logical-scalar-ids.cpp

  • This file was added.
// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fmcdc -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only %s | FileCheck %s
extern bool bar (bool, bool, bool, bool, bool);
bool func_scalar_and(bool a, bool b, bool c, bool d, bool e, bool f) {
bool res1 = a && b;
bool res2 = a && b && c;
bool res3 = a && b && c && d;
bool res4 = a && b && c && d && e;
bool res5 = a && b && c && d && e && f;
return bar(res1, res2, res3, res4, res5);
}
// CHECK: Decision,File 0, 5:17 -> 5:23 = M:0, C:2
// CHECK: Branch,File 0, 5:17 -> 5:18 = #1, (#0 - #1) [1,2,0]
// CHECK: Branch,File 0, 5:22 -> 5:23 = #2, (#1 - #2) [2,0,0]
// CHECK: Decision,File 0, 6:17 -> 6:28 = M:1, C:3
// CHECK: Branch,File 0, 6:17 -> 6:18 = #5, (#0 - #5) [1,3,0]
// CHECK: Branch,File 0, 6:22 -> 6:23 = #6, (#5 - #6) [3,2,0]
// CHECK: Branch,File 0, 6:27 -> 6:28 = #4, (#3 - #4) [2,0,0]
// CHECK: Decision,File 0, 7:17 -> 7:33 = M:2, C:4
// CHECK: Branch,File 0, 7:17 -> 7:18 = #11, (#0 - #11) [1,4,0]
// CHECK: Branch,File 0, 7:22 -> 7:23 = #12, (#11 - #12) [4,3,0]
// CHECK: Branch,File 0, 7:27 -> 7:28 = #10, (#9 - #10) [3,2,0]
// CHECK: Branch,File 0, 7:32 -> 7:33 = #8, (#7 - #8) [2,0,0]
// CHECK: Decision,File 0, 8:17 -> 8:38 = M:4, C:5
// CHECK: Branch,File 0, 8:17 -> 8:18 = #19, (#0 - #19) [1,5,0]
// CHECK: Branch,File 0, 8:22 -> 8:23 = #20, (#19 - #20) [5,4,0]
// CHECK: Branch,File 0, 8:27 -> 8:28 = #18, (#17 - #18) [4,3,0]
// CHECK: Branch,File 0, 8:32 -> 8:33 = #16, (#15 - #16) [3,2,0]
// CHECK: Branch,File 0, 8:37 -> 8:38 = #14, (#13 - #14) [2,0,0]
// CHECK: Decision,File 0, 9:17 -> 9:43 = M:8, C:6
// CHECK: Branch,File 0, 9:17 -> 9:18 = #29, (#0 - #29) [1,6,0]
// CHECK: Branch,File 0, 9:22 -> 9:23 = #30, (#29 - #30) [6,5,0]
// CHECK: Branch,File 0, 9:27 -> 9:28 = #28, (#27 - #28) [5,4,0]
// CHECK: Branch,File 0, 9:32 -> 9:33 = #26, (#25 - #26) [4,3,0]
// CHECK: Branch,File 0, 9:37 -> 9:38 = #24, (#23 - #24) [3,2,0]
// CHECK: Branch,File 0, 9:42 -> 9:43 = #22, (#21 - #22) [2,0,0]
bool func_scalar_or(bool a, bool b, bool c, bool d, bool e, bool f) {
bool res1 = a || b;
bool res2 = a || b || c;
bool res3 = a || b || c || d;
bool res4 = a || b || c || d || e;
bool res5 = a || b || c || d || e || f;
return bar(res1, res2, res3, res4, res5);
}
// CHECK: Decision,File 0, 40:17 -> 40:23 = M:0, C:2
// CHECK: Branch,File 0, 40:17 -> 40:18 = (#0 - #1), #1 [1,0,2]
// CHECK: Branch,File 0, 40:22 -> 40:23 = (#1 - #2), #2 [2,0,0]
// CHECK: Decision,File 0, 41:17 -> 41:28 = M:1, C:3
// CHECK: Branch,File 0, 41:17 -> 41:18 = (#0 - #5), #5 [1,0,3]
// CHECK: Branch,File 0, 41:22 -> 41:23 = (#5 - #6), #6 [3,0,2]
// CHECK: Branch,File 0, 41:27 -> 41:28 = (#3 - #4), #4 [2,0,0]
// CHECK: Decision,File 0, 42:17 -> 42:33 = M:2, C:4
// CHECK: Branch,File 0, 42:17 -> 42:18 = (#0 - #11), #11 [1,0,4]
// CHECK: Branch,File 0, 42:22 -> 42:23 = (#11 - #12), #12 [4,0,3]
// CHECK: Branch,File 0, 42:27 -> 42:28 = (#9 - #10), #10 [3,0,2]
// CHECK: Branch,File 0, 42:32 -> 42:33 = (#7 - #8), #8 [2,0,0]
// CHECK: Decision,File 0, 43:17 -> 43:38 = M:4, C:5
// CHECK: Branch,File 0, 43:17 -> 43:18 = (#0 - #19), #19 [1,0,5]
// CHECK: Branch,File 0, 43:22 -> 43:23 = (#19 - #20), #20 [5,0,4]
// CHECK: Branch,File 0, 43:27 -> 43:28 = (#17 - #18), #18 [4,0,3]
// CHECK: Branch,File 0, 43:32 -> 43:33 = (#15 - #16), #16 [3,0,2]
// CHECK: Branch,File 0, 43:37 -> 43:38 = (#13 - #14), #14 [2,0,0]
// CHECK: Decision,File 0, 44:17 -> 44:43 = M:8, C:6
// CHECK: Branch,File 0, 44:17 -> 44:18 = (#0 - #29), #29 [1,0,6]
// CHECK: Branch,File 0, 44:22 -> 44:23 = (#29 - #30), #30 [6,0,5]
// CHECK: Branch,File 0, 44:27 -> 44:28 = (#27 - #28), #28 [5,0,4]
// CHECK: Branch,File 0, 44:32 -> 44:33 = (#25 - #26), #26 [4,0,3]
// CHECK: Branch,File 0, 44:37 -> 44:38 = (#23 - #24), #24 [3,0,2]
// CHECK: Branch,File 0, 44:42 -> 44:43 = (#21 - #22), #22 [2,0,0]
bool func_scalar_mix(bool a, bool b, bool c, bool d, bool e, bool f) {
bool res1 = a || b;
bool res2 = a && (b || c);
bool res3 = (a || b) && (c || d);
bool res4 = a && (b || c) && (d || e);
bool res5 = (a || b) && (c || d) && (e || f);
return bar(res1, res2, res3, res4, res5);
}
// CHECK: Decision,File 0, 76:17 -> 76:23 = M:0, C:2
// CHECK: Branch,File 0, 76:17 -> 76:18 = (#0 - #1), #1 [1,0,2]
// CHECK: Branch,File 0, 76:22 -> 76:23 = (#1 - #2), #2 [2,0,0]
// CHECK: Decision,File 0, 77:17 -> 77:30 = M:1, C:3
// CHECK: Branch,File 0, 77:17 -> 77:18 = #3, (#0 - #3) [1,2,0]
// CHECK: Branch,File 0, 77:23 -> 77:24 = (#3 - #4), #4 [2,0,3]
// CHECK: Branch,File 0, 77:28 -> 77:29 = (#4 - #5), #5 [3,0,0]
// CHECK: Decision,File 0, 78:17 -> 78:37 = M:2, C:4
// CHECK: Branch,File 0, 78:18 -> 78:19 = (#0 - #7), #7 [1,2,3]
// CHECK: Branch,File 0, 78:23 -> 78:24 = (#7 - #8), #8 [3,2,0]
// CHECK: Branch,File 0, 78:30 -> 78:31 = (#6 - #9), #9 [2,0,4]
// CHECK: Branch,File 0, 78:35 -> 78:36 = (#9 - #10), #10 [4,0,0]
// CHECK: Decision,File 0, 79:17 -> 79:42 = M:4, C:5
// CHECK: Branch,File 0, 79:17 -> 79:18 = #12, (#0 - #12) [1,3,0]
// CHECK: Branch,File 0, 79:23 -> 79:24 = (#12 - #13), #13 [3,2,4]
// CHECK: Branch,File 0, 79:28 -> 79:29 = (#13 - #14), #14 [4,2,0]
// CHECK: Branch,File 0, 79:35 -> 79:36 = (#11 - #15), #15 [2,0,5]
// CHECK: Branch,File 0, 79:40 -> 79:41 = (#15 - #16), #16 [5,0,0]
// CHECK: Decision,File 0, 80:17 -> 80:49 = M:8, C:6
// CHECK: Branch,File 0, 80:18 -> 80:19 = (#0 - #19), #19 [1,3,4]
// CHECK: Branch,File 0, 80:23 -> 80:24 = (#19 - #20), #20 [4,3,0]
// CHECK: Branch,File 0, 80:30 -> 80:31 = (#18 - #21), #21 [3,2,5]
// CHECK: Branch,File 0, 80:35 -> 80:36 = (#21 - #22), #22 [5,2,0]
// CHECK: Branch,File 0, 80:42 -> 80:43 = (#17 - #23), #23 [2,0,6]
// CHECK: Branch,File 0, 80:47 -> 80:48 = (#23 - #24), #24 [6,0,0]

clang/test/CoverageMapping/mcdc-logical-stmt-ids-all.cpp

  • This file was added.
// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fmcdc -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only %s | FileCheck %s
bool func_if_and(bool a, bool b, bool c, bool d, bool e, bool f) {
if (a && b && c && d && e && f)
return true;
return false;
}
// CHECK: Decision,File 0, 4:7 -> 4:33 = M:0, C:6
// CHECK: Branch,File 0, 4:7 -> 4:8 = #10, (#0 - #10) [1,6,0]
// CHECK: Branch,File 0, 4:12 -> 4:13 = #11, (#10 - #11) [6,5,0]
// CHECK: Branch,File 0, 4:17 -> 4:18 = #9, (#8 - #9) [5,4,0]
// CHECK: Branch,File 0, 4:22 -> 4:23 = #7, (#6 - #7) [4,3,0]
// CHECK: Branch,File 0, 4:27 -> 4:28 = #5, (#4 - #5) [3,2,0]
// CHECK: Branch,File 0, 4:32 -> 4:33 = #3, (#2 - #3) [2,0,0]
bool func_if_or(bool a, bool b, bool c, bool d, bool e, bool f) {
if (a || b || c || d || e || f)
return true;
return false;
}
// CHECK: Decision,File 0, 18:7 -> 18:33 = M:0, C:6
// CHECK: Branch,File 0, 18:7 -> 18:8 = (#0 - #10), #10 [1,0,6]
// CHECK: Branch,File 0, 18:12 -> 18:13 = (#10 - #11), #11 [6,0,5]
// CHECK: Branch,File 0, 18:17 -> 18:18 = (#8 - #9), #9 [5,0,4]
// CHECK: Branch,File 0, 18:22 -> 18:23 = (#6 - #7), #7 [4,0,3]
// CHECK: Branch,File 0, 18:27 -> 18:28 = (#4 - #5), #5 [3,0,2]
// CHECK: Branch,File 0, 18:32 -> 18:33 = (#2 - #3), #3 [2,0,0]
bool func_while_and(bool a, bool b, bool c, bool d, bool e, bool f) {
while (a && b && c && d && e && f) { return true; }
return false;
}
// CHECK: Decision,File 0, 32:10 -> 32:36 = M:0, C:6
// CHECK: Branch,File 0, 32:10 -> 32:11 = #10, (#0 - #10) [1,6,0]
// CHECK: Branch,File 0, 32:15 -> 32:16 = #11, (#10 - #11) [6,5,0]
// CHECK: Branch,File 0, 32:20 -> 32:21 = #9, (#8 - #9) [5,4,0]
// CHECK: Branch,File 0, 32:25 -> 32:26 = #7, (#6 - #7) [4,3,0]
// CHECK: Branch,File 0, 32:30 -> 32:31 = #5, (#4 - #5) [3,2,0]
// CHECK: Branch,File 0, 32:35 -> 32:36 = #3, (#2 - #3) [2,0,0]
bool func_while_or(bool a, bool b, bool c, bool d, bool e, bool f) {
while (a || b || c || d || e || f) { return true; }
return false;
}
// CHECK: Decision,File 0, 45:10 -> 45:36 = M:0, C:6
// CHECK: Branch,File 0, 45:10 -> 45:11 = (#0 - #10), #10 [1,0,6]
// CHECK: Branch,File 0, 45:15 -> 45:16 = (#10 - #11), #11 [6,0,5]
// CHECK: Branch,File 0, 45:20 -> 45:21 = (#8 - #9), #9 [5,0,4]
// CHECK: Branch,File 0, 45:25 -> 45:26 = (#6 - #7), #7 [4,0,3]
// CHECK: Branch,File 0, 45:30 -> 45:31 = (#4 - #5), #5 [3,0,2]
// CHECK: Branch,File 0, 45:35 -> 45:36 = (#2 - #3), #3 [2,0,0]
bool func_for_and(bool a, bool b, bool c, bool d, bool e, bool f) {
for (;a && b && c && d && e && f;) { return true; }
return false;
}
// CHECK: Decision,File 0, 58:9 -> 58:35 = M:0, C:6
// CHECK: Branch,File 0, 58:9 -> 58:10 = #10, (#0 - #10) [1,6,0]
// CHECK: Branch,File 0, 58:14 -> 58:15 = #11, (#10 - #11) [6,5,0]
// CHECK: Branch,File 0, 58:19 -> 58:20 = #9, (#8 - #9) [5,4,0]
// CHECK: Branch,File 0, 58:24 -> 58:25 = #7, (#6 - #7) [4,3,0]
// CHECK: Branch,File 0, 58:29 -> 58:30 = #5, (#4 - #5) [3,2,0]
// CHECK: Branch,File 0, 58:34 -> 58:35 = #3, (#2 - #3) [2,0,0]
bool func_for_or(bool a, bool b, bool c, bool d, bool e, bool f) {
for (;a || b || c || d || e || f;) { return true; }
return false;
}
// CHECK: Decision,File 0, 71:9 -> 71:35 = M:0, C:6
// CHECK: Branch,File 0, 71:9 -> 71:10 = (#0 - #10), #10 [1,0,6]
// CHECK: Branch,File 0, 71:14 -> 71:15 = (#10 - #11), #11 [6,0,5]
// CHECK: Branch,File 0, 71:19 -> 71:20 = (#8 - #9), #9 [5,0,4]
// CHECK: Branch,File 0, 71:24 -> 71:25 = (#6 - #7), #7 [4,0,3]
// CHECK: Branch,File 0, 71:29 -> 71:30 = (#4 - #5), #5 [3,0,2]
// CHECK: Branch,File 0, 71:34 -> 71:35 = (#2 - #3), #3 [2,0,0]
bool func_do_and(bool a, bool b, bool c, bool d, bool e, bool f) {
do {} while (a && b && c && d && e && f);
return false;
}
// CHECK: Decision,File 0, 84:16 -> 84:42 = M:0, C:6
// CHECK: Branch,File 0, 84:16 -> 84:17 = #10, ((#0 + #1) - #10) [1,6,0]
// CHECK: Branch,File 0, 84:21 -> 84:22 = #11, (#10 - #11) [6,5,0]
// CHECK: Branch,File 0, 84:26 -> 84:27 = #9, (#8 - #9) [5,4,0]
// CHECK: Branch,File 0, 84:31 -> 84:32 = #7, (#6 - #7) [4,3,0]
// CHECK: Branch,File 0, 84:36 -> 84:37 = #5, (#4 - #5) [3,2,0]
// CHECK: Branch,File 0, 84:41 -> 84:42 = #3, (#2 - #3) [2,0,0]
bool func_do_or(bool a, bool b, bool c, bool d, bool e, bool f) {
do {} while (a || b || c || d || e || f);
return false;
}
// CHECK: Decision,File 0, 97:16 -> 97:42 = M:0, C:6
// CHECK: Branch,File 0, 97:16 -> 97:17 = ((#0 + #1) - #10), #10 [1,0,6]
// CHECK: Branch,File 0, 97:21 -> 97:22 = (#10 - #11), #11 [6,0,5]
// CHECK: Branch,File 0, 97:26 -> 97:27 = (#8 - #9), #9 [5,0,4]
// CHECK: Branch,File 0, 97:31 -> 97:32 = (#6 - #7), #7 [4,0,3]
// CHECK: Branch,File 0, 97:36 -> 97:37 = (#4 - #5), #5 [3,0,2]
// CHECK: Branch,File 0, 97:41 -> 97:42 = (#2 - #3), #3 [2,0,0]
bool func_ternary_and(bool a, bool b, bool c, bool d, bool e, bool f) {
return (a && b && c && d && e && f) ? true : false;
}
// CHECK: Decision,File 0, 110:11 -> 110:37 = M:0, C:6
// CHECK: Branch,File 0, 110:11 -> 110:12 = #10, (#0 - #10) [1,6,0]
// CHECK: Branch,File 0, 110:16 -> 110:17 = #11, (#10 - #11) [6,5,0]
// CHECK: Branch,File 0, 110:21 -> 110:22 = #9, (#8 - #9) [5,4,0]
// CHECK: Branch,File 0, 110:26 -> 110:27 = #7, (#6 - #7) [4,3,0]
// CHECK: Branch,File 0, 110:31 -> 110:32 = #5, (#4 - #5) [3,2,0]
// CHECK: Branch,File 0, 110:36 -> 110:37 = #3, (#2 - #3) [2,0,0]
bool func_ternary_or(bool a, bool b, bool c, bool d, bool e, bool f) {
return (a || b || c || d || e || f) ? true : false;
}
// CHECK: Decision,File 0, 122:11 -> 122:37 = M:0, C:6
// CHECK: Branch,File 0, 122:11 -> 122:12 = (#0 - #10), #10 [1,0,6]
// CHECK: Branch,File 0, 122:16 -> 122:17 = (#10 - #11), #11 [6,0,5]
// CHECK: Branch,File 0, 122:21 -> 122:22 = (#8 - #9), #9 [5,0,4]
// CHECK: Branch,File 0, 122:26 -> 122:27 = (#6 - #7), #7 [4,0,3]
// CHECK: Branch,File 0, 122:31 -> 122:32 = (#4 - #5), #5 [3,0,2]
// CHECK: Branch,File 0, 122:36 -> 122:37 = (#2 - #3), #3 [2,0,0]

clang/test/CoverageMapping/mcdc-logical-stmt-ids.cpp

  • This file was added.
// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fmcdc -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only %s | FileCheck %s
bool func_if_and(bool a, bool b, bool c, bool d, bool e, bool f) {
if (a && b)
if (a && b && c)
if (a && b && c && d)
if (a && b && c && d && e)
if (a && b && c && d && e && f)
return true;
return false;
}
// CHECK: Decision,File 0, 4:7 -> 4:13 = M:0, C:2
// CHECK: Branch,File 0, 4:7 -> 4:8 = #2, (#0 - #2) [1,2,0]
// CHECK: Branch,File 0, 4:12 -> 4:13 = #3, (#2 - #3) [2,0,0]
// CHECK: Decision,File 0, 5:9 -> 5:20 = M:1, C:3
// CHECK: Branch,File 0, 5:9 -> 5:10 = #7, (#1 - #7) [1,3,0]
// CHECK: Branch,File 0, 5:14 -> 5:15 = #8, (#7 - #8) [3,2,0]
// CHECK: Branch,File 0, 5:19 -> 5:20 = #6, (#5 - #6) [2,0,0]
// CHECK: Decision,File 0, 6:11 -> 6:27 = M:2, C:4
// CHECK: Branch,File 0, 6:11 -> 6:12 = #14, (#4 - #14) [1,4,0]
// CHECK: Branch,File 0, 6:16 -> 6:17 = #15, (#14 - #15) [4,3,0]
// CHECK: Branch,File 0, 6:21 -> 6:22 = #13, (#12 - #13) [3,2,0]
// CHECK: Branch,File 0, 6:26 -> 6:27 = #11, (#10 - #11) [2,0,0]
// CHECK: Decision,File 0, 7:13 -> 7:34 = M:4, C:5
// CHECK: Branch,File 0, 7:13 -> 7:14 = #23, (#9 - #23) [1,5,0]
// CHECK: Branch,File 0, 7:18 -> 7:19 = #24, (#23 - #24) [5,4,0]
// CHECK: Branch,File 0, 7:23 -> 7:24 = #22, (#21 - #22) [4,3,0]
// CHECK: Branch,File 0, 7:28 -> 7:29 = #20, (#19 - #20) [3,2,0]
// CHECK: Branch,File 0, 7:33 -> 7:34 = #18, (#17 - #18) [2,0,0]
// CHECK: Decision,File 0, 8:16 -> 8:42 = M:8, C:6
// CHECK: Branch,File 0, 8:16 -> 8:17 = #34, (#16 - #34) [1,6,0]
// CHECK: Branch,File 0, 8:21 -> 8:22 = #35, (#34 - #35) [6,5,0]
// CHECK: Branch,File 0, 8:26 -> 8:27 = #33, (#32 - #33) [5,4,0]
// CHECK: Branch,File 0, 8:31 -> 8:32 = #31, (#30 - #31) [4,3,0]
// CHECK: Branch,File 0, 8:36 -> 8:37 = #29, (#28 - #29) [3,2,0]
// CHECK: Branch,File 0, 8:41 -> 8:42 = #27, (#26 - #27) [2,0,0]
bool func_if_or(bool a, bool b, bool c, bool d, bool e, bool f) {
if (a || b)
if (a || b || c)
if (a || b || c || d)
if (a || b || c || d || e)
if (a || b || c || d || e || f)
return true;
return false;
}
// CHECK: Decision,File 0, 40:7 -> 40:13 = M:0, C:2
// CHECK: Branch,File 0, 40:7 -> 40:8 = (#0 - #2), #2 [1,0,2]
// CHECK: Branch,File 0, 40:12 -> 40:13 = (#2 - #3), #3 [2,0,0]
// CHECK: Decision,File 0, 41:9 -> 41:20 = M:1, C:3
// CHECK: Branch,File 0, 41:9 -> 41:10 = (#1 - #7), #7 [1,0,3]
// CHECK: Branch,File 0, 41:14 -> 41:15 = (#7 - #8), #8 [3,0,2]
// CHECK: Branch,File 0, 41:19 -> 41:20 = (#5 - #6), #6 [2,0,0]
// CHECK: Decision,File 0, 42:11 -> 42:27 = M:2, C:4
// CHECK: Branch,File 0, 42:11 -> 42:12 = (#4 - #14), #14 [1,0,4]
// CHECK: Branch,File 0, 42:16 -> 42:17 = (#14 - #15), #15 [4,0,3]
// CHECK: Branch,File 0, 42:21 -> 42:22 = (#12 - #13), #13 [3,0,2]
// CHECK: Branch,File 0, 42:26 -> 42:27 = (#10 - #11), #11 [2,0,0]
// CHECK: Decision,File 0, 43:13 -> 43:34 = M:4, C:5
// CHECK: Branch,File 0, 43:13 -> 43:14 = (#9 - #23), #23 [1,0,5]
// CHECK: Branch,File 0, 43:18 -> 43:19 = (#23 - #24), #24 [5,0,4]
// CHECK: Branch,File 0, 43:23 -> 43:24 = (#21 - #22), #22 [4,0,3]
// CHECK: Branch,File 0, 43:28 -> 43:29 = (#19 - #20), #20 [3,0,2]
// CHECK: Branch,File 0, 43:33 -> 43:34 = (#17 - #18), #18 [2,0,0]
// CHECK: Decision,File 0, 44:16 -> 44:42 = M:8, C:6
// CHECK: Branch,File 0, 44:16 -> 44:17 = (#16 - #34), #34 [1,0,6]
// CHECK: Branch,File 0, 44:21 -> 44:22 = (#34 - #35), #35 [6,0,5]
// CHECK: Branch,File 0, 44:26 -> 44:27 = (#32 - #33), #33 [5,0,4]
// CHECK: Branch,File 0, 44:31 -> 44:32 = (#30 - #31), #31 [4,0,3]
// CHECK: Branch,File 0, 44:36 -> 44:37 = (#28 - #29), #29 [3,0,2]
// CHECK: Branch,File 0, 44:41 -> 44:42 = (#26 - #27), #27 [2,0,0]
bool func_if_mix(bool a, bool b, bool c, bool d, bool e, bool f) {
if (a || b)
if (a && (b || c))
if ((a || b) && (c || d))
if (a && (b || c) && (d || e))
if ((a || b) && (c || d) && (e || f))
return true;
return false;
}
// CHECK: Decision,File 0, 76:7 -> 76:13 = M:0, C:2
// CHECK: Branch,File 0, 76:7 -> 76:8 = (#0 - #2), #2 [1,0,2]
// CHECK: Branch,File 0, 76:12 -> 76:13 = (#2 - #3), #3 [2,0,0]
// CHECK: Decision,File 0, 77:9 -> 77:22 = M:1, C:3
// CHECK: Branch,File 0, 77:9 -> 77:10 = #5, (#1 - #5) [1,2,0]
// CHECK: Branch,File 0, 77:15 -> 77:16 = (#5 - #6), #6 [2,0,3]
// CHECK: Branch,File 0, 77:20 -> 77:21 = (#6 - #7), #7 [3,0,0]
// CHECK: Decision,File 0, 78:11 -> 78:31 = M:2, C:4
// CHECK: Branch,File 0, 78:12 -> 78:13 = (#4 - #10), #10 [1,2,3]
// CHECK: Branch,File 0, 78:17 -> 78:18 = (#10 - #11), #11 [3,2,0]
// CHECK: Branch,File 0, 78:24 -> 78:25 = (#9 - #12), #12 [2,0,4]
// CHECK: Branch,File 0, 78:29 -> 78:30 = (#12 - #13), #13 [4,0,0]
// CHECK: Decision,File 0, 79:13 -> 79:38 = M:4, C:5
// CHECK: Branch,File 0, 79:13 -> 79:14 = #16, (#8 - #16) [1,3,0]
// CHECK: Branch,File 0, 79:19 -> 79:20 = (#16 - #17), #17 [3,2,4]
// CHECK: Branch,File 0, 79:24 -> 79:25 = (#17 - #18), #18 [4,2,0]
// CHECK: Branch,File 0, 79:31 -> 79:32 = (#15 - #19), #19 [2,0,5]
// CHECK: Branch,File 0, 79:36 -> 79:37 = (#19 - #20), #20 [5,0,0]
// CHECK: Decision,File 0, 80:15 -> 80:47 = M:8, C:6
// CHECK: Branch,File 0, 80:16 -> 80:17 = (#14 - #24), #24 [1,3,4]
// CHECK: Branch,File 0, 80:21 -> 80:22 = (#24 - #25), #25 [4,3,0]
// CHECK: Branch,File 0, 80:28 -> 80:29 = (#23 - #26), #26 [3,2,5]
// CHECK: Branch,File 0, 80:33 -> 80:34 = (#26 - #27), #27 [5,2,0]
// CHECK: Branch,File 0, 80:40 -> 80:41 = (#22 - #28), #28 [2,0,6]
// CHECK: Branch,File 0, 80:45 -> 80:46 = (#28 - #29), #29 [6,0,0]

clang/test/Driver/darwin-ld.c

Show First 20 Lines • Show All 330 Lines • ▼ Show 20 Lines
// LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1.2.6' // LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1.2.6'
// LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1.a' // LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1.a'
// LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1a' // LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1a'
// RUN: %clang -target x86_64-apple-darwin12 -fprofile-instr-generate -### %t.o 2> %t.log // RUN: %clang -target x86_64-apple-darwin12 -fprofile-instr-generate -### %t.o 2> %t.log
// RUN: FileCheck -check-prefix=PROFILE_SECTALIGN %s < %t.log // RUN: FileCheck -check-prefix=PROFILE_SECTALIGN %s < %t.log
// RUN: %clang -target arm64-apple-ios12 -fprofile-instr-generate -### %t.o 2> %t.log // RUN: %clang -target arm64-apple-ios12 -fprofile-instr-generate -### %t.o 2> %t.log
// RUN: FileCheck -check-prefix=PROFILE_SECTALIGN %s < %t.log // RUN: FileCheck -check-prefix=PROFILE_SECTALIGN %s < %t.log
// PROFILE_SECTALIGN: "-sectalign" "__DATA" "__llvm_prf_cnts" "0x4000" "-sectalign" "__DATA" "__llvm_prf_data" "0x4000" // PROFILE_SECTALIGN: "-sectalign" "__DATA" "__llvm_prf_cnts" "0x4000" "-sectalign" "__DATA" "__llvm_prf_bits" "0x4000" "-sectalign" "__DATA" "__llvm_prf_data" "0x4000"
// RUN: %clang -target x86_64-apple-darwin12 -fprofile-instr-generate -exported_symbols_list /dev/null -### %t.o 2> %t.log // RUN: %clang -target x86_64-apple-darwin12 -fprofile-instr-generate -exported_symbols_list /dev/null -### %t.o 2> %t.log
// RUN: FileCheck -check-prefix=PROFILE_EXPORT %s < %t.log // RUN: FileCheck -check-prefix=PROFILE_EXPORT %s < %t.log
// RUN: %clang -target x86_64-apple-darwin12 -fprofile-instr-generate -Wl,-exported_symbols_list,/dev/null -### %t.o 2> %t.log // RUN: %clang -target x86_64-apple-darwin12 -fprofile-instr-generate -Wl,-exported_symbols_list,/dev/null -### %t.o 2> %t.log
// RUN: FileCheck -check-prefix=PROFILE_EXPORT %s < %t.log // RUN: FileCheck -check-prefix=PROFILE_EXPORT %s < %t.log
// RUN: %clang -target x86_64-apple-darwin12 -fprofile-instr-generate -Wl,-exported_symbol,foo -### %t.o 2> %t.log // RUN: %clang -target x86_64-apple-darwin12 -fprofile-instr-generate -Wl,-exported_symbol,foo -### %t.o 2> %t.log
// RUN: FileCheck -check-prefix=PROFILE_EXPORT %s < %t.log // RUN: FileCheck -check-prefix=PROFILE_EXPORT %s < %t.log
// RUN: %clang -target x86_64-apple-darwin12 -fprofile-instr-generate -Xlinker -exported_symbol -Xlinker foo -### %t.o 2> %t.log // RUN: %clang -target x86_64-apple-darwin12 -fprofile-instr-generate -Xlinker -exported_symbol -Xlinker foo -### %t.o 2> %t.log
Show All 33 Lines

clang/test/Profile/c-linkage-available_externally.c

// Make sure instrumentation data from available_externally functions doesn't // Make sure instrumentation data from available_externally functions doesn't
// get thrown out and are emitted with the expected linkage. // get thrown out and are emitted with the expected linkage.
// RUN: %clang_cc1 -no-opaque-pointers -O2 -triple x86_64-apple-macosx10.9 -main-file-name c-linkage-available_externally.c %s -o - -emit-llvm -fprofile-instrument=clang | FileCheck %s // RUN: %clang_cc1 -no-opaque-pointers -O2 -triple x86_64-apple-macosx10.9 -main-file-name c-linkage-available_externally.c %s -o - -emit-llvm -fprofile-instrument=clang | FileCheck %s
// RUN: %clang_cc1 -fmcdc -no-opaque-pointers -O2 -triple x86_64-apple-macosx10.9 -main-file-name c-linkage-available_externally.c %s -o - -emit-llvm -fprofile-instrument=clang | FileCheck %s -check-prefix=MCDC
// CHECK: @__profc_foo = linkonce_odr hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 // CHECK: @__profc_foo = linkonce_odr hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8
// CHECK: @__profd_foo = linkonce_odr hidden global {{.*}} i64 sub (i64 ptrtoint ([1 x i64]* @__profc_foo to i64), i64 ptrtoint ({ i64, i64, i64, i8*, i8*, i32, [2 x i16] }* @__profd_foo to i64)), {{.*}}, section "__DATA,__llvm_prf_data,regular,live_support", align 8 // MCDC: @__profbm_foo = linkonce_odr hidden global [0 x i8] zeroinitializer, section "__DATA,__llvm_prf_bits", align 1
// CHECK: @__profd_foo = linkonce_odr hidden global {{.*}} i64 sub (i64 ptrtoint ([1 x i64]* @__profc_foo to i64), i64 ptrtoint ({ i64, i64, i64, i64, i8*, i8*, i32, [2 x i16], i32 }* @__profd_foo to i64)), {{.*}}, section "__DATA,__llvm_prf_data,regular,live_support", align 8
inline int foo(void) { return 1; } inline int foo(void) { return 1; }
int main(void) { int main(void) {
return foo(); return foo();
} }

clang/test/Profile/c-mcdc-nested-ternary.c

  • This file was added.
// RUN: %clang_cc1 -triple %itanium_abi_triple %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -fmcdc | FileCheck %s -check-prefix=MCDC
// RUN: %clang_cc1 -triple %itanium_abi_triple %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping | FileCheck %s -check-prefix=NOMCDC
int test(int b, int c, int d, int e, int f) {
return ((b ? c : d) && e && f);
}
// NOMCDC-NOT: %mcdc.addr
// NOMCDC-NOT: __profbm_test
// MCDC BOOKKEEPING.
// MCDC: @__profbm_test = private global [1 x i8] zeroinitializer
// ALLOCATE MCDC TEMP AND ZERO IT.
// MCDC-LABEL: @test(
// MCDC: %mcdc.addr = alloca i32, align 4
// MCDC: store i32 0, ptr %mcdc.addr, align 4
// TERNARY TRUE SHOULD SHIFT ID = 0 FOR CONDITION 'c'.
// MCDC-LABEL: cond.true:
// MCDC: %[[LAB1:[0-9]+]] = load i32, ptr %c.addr, align 4
// MCDC-DAG: %[[BOOL:tobool[0-9]*]] = icmp ne i32 %[[LAB1]], 0
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC-DAG: %[[LAB2:[0-9]+]] = zext i1 %[[BOOL]] to i32
// MCDC-DAG: %[[LAB3:[0-9]+]] = shl i32 %[[LAB2]], 0
// MCDC-DAG: %[[LAB4:[0-9]+]] = or i32 %[[TEMP]], %[[LAB3]]
// MCDC-DAG: store i32 %[[LAB4]], ptr %mcdc.addr, align 4
// TERNARY FALSE SHOULD SHIFT ID = 0 FOR CONDITION 'd'.
// MCDC-LABEL: cond.false:
// MCDC: %[[LAB1:[0-9]+]] = load i32, ptr %d.addr, align 4
// MCDC-DAG: %[[BOOL:tobool[0-9]*]] = icmp ne i32 %[[LAB1]], 0
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC-DAG: %[[LAB2:[0-9]+]] = zext i1 %[[BOOL]] to i32
// MCDC-DAG: %[[LAB3:[0-9]+]] = shl i32 %[[LAB2]], 0
// MCDC-DAG: %[[LAB4:[0-9]+]] = or i32 %[[TEMP]], %[[LAB3]]
// MCDC-DAG: store i32 %[[LAB4]], ptr %mcdc.addr, align 4
// SHIFT SECOND CONDITION WITH ID = 2.
// MCDC: %[[LAB1:[0-9]+]] = load i32, ptr %e.addr, align 4
// MCDC-DAG: %[[BOOL:tobool[0-9]*]] = icmp ne i32 %[[LAB1]], 0
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC-DAG: %[[LAB2:[0-9]+]] = zext i1 %[[BOOL]] to i32
// MCDC-DAG: %[[LAB3:[0-9]+]] = shl i32 %[[LAB2]], 2
// MCDC-DAG: %[[LAB4:[0-9]+]] = or i32 %[[TEMP]], %[[LAB3]]
// MCDC-DAG: store i32 %[[LAB4]], ptr %mcdc.addr, align 4
// SHIFT THIRD CONDITION WITH ID = 1.
// MCDC: %[[LAB1:[0-9]+]] = load i32, ptr %f.addr, align 4
// MCDC-DAG: %[[BOOL:tobool[0-9]*]] = icmp ne i32 %[[LAB1]], 0
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC-DAG: %[[LAB2:[0-9]+]] = zext i1 %[[BOOL]] to i32
// MCDC-DAG: %[[LAB3:[0-9]+]] = shl i32 %[[LAB2]], 1
// MCDC-DAG: %[[LAB4:[0-9]+]] = or i32 %[[TEMP]], %[[LAB3]]
// MCDC-DAG: store i32 %[[LAB4]], ptr %mcdc.addr, align 4
// UPDATE FINAL BITMASK WITH RESULT.
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC: %[[LAB1:[0-9]+]] = lshr i32 %[[TEMP]], 3
// MCDC: %[[LAB2:[0-9]+]] = zext i32 %[[LAB1]] to i64
// MCDC: %[[LAB3:[0-9]+]] = add i64 ptrtoint (ptr @__profbm_test to i64), %[[LAB2]]
// MCDC: %[[LAB4:[0-9]+]] = inttoptr i64 %[[LAB3]] to ptr
// MCDC: %[[LAB5:[0-9]+]] = and i32 %[[TEMP]], 7
// MCDC: %[[LAB6:[0-9]+]] = trunc i32 %[[LAB5]] to i8
// MCDC: %[[LAB7:[0-9]+]] = shl i8 1, %[[LAB6]]
// MCDC: %mcdc.bits = load i8, ptr %[[LAB4]], align 1
// MCDC: %[[LAB8:[0-9]+]] = or i8 %mcdc.bits, %[[LAB7]]
// MCDC: store i8 %[[LAB8]], ptr %[[LAB4]], align 1

clang/test/Profile/c-mcdc.c

  • This file was added.
// RUN: %clang_cc1 -triple %itanium_abi_triple %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -fmcdc | FileCheck %s -check-prefix=MCDC
// RUN: %clang_cc1 -triple %itanium_abi_triple %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping | FileCheck %s -check-prefix=NOMCDC
int test(int a, int b, int c, int d, int e, int f) {
return ((a && b) || ((c && d) || (e && f)));
}
// NOMCDC-NOT: %mcdc.addr
// NOMCDC-NOT: __profbm_test
// MCDC BOOKKEEPING.
// MCDC: @__profbm_test = private global [8 x i8] zeroinitializer
// MCDC: @__profc_test = private global [9 x i64] zeroinitializer
// ALLOCATE MCDC TEMP AND ZERO IT.
// MCDC-LABEL: @test(
// MCDC: %mcdc.addr = alloca i32, align 4
// MCDC: store i32 0, ptr %mcdc.addr, align 4
// SHIFT FIRST CONDITION WITH ID = 0.
// MCDC: %[[LAB1:[0-9]+]] = load i32, ptr %a.addr, align 4
// MCDC-DAG: %[[BOOL:tobool[0-9]*]] = icmp ne i32 %[[LAB1]], 0
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC-DAG: %[[LAB2:[0-9]+]] = zext i1 %[[BOOL]] to i32
// MCDC-DAG: %[[LAB3:[0-9]+]] = shl i32 %[[LAB2]], 0
// MCDC-DAG: %[[LAB4:[0-9]+]] = or i32 %[[TEMP]], %[[LAB3]]
// MCDC-DAG: store i32 %[[LAB4]], ptr %mcdc.addr, align 4
// SHIFT SECOND CONDITION WITH ID = 2.
// MCDC: %[[LAB1:[0-9]+]] = load i32, ptr %b.addr, align 4
// MCDC-DAG: %[[BOOL:tobool[0-9]*]] = icmp ne i32 %[[LAB1]], 0
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC-DAG: %[[LAB2:[0-9]+]] = zext i1 %[[BOOL]] to i32
// MCDC-DAG: %[[LAB3:[0-9]+]] = shl i32 %[[LAB2]], 2
// MCDC-DAG: %[[LAB4:[0-9]+]] = or i32 %[[TEMP]], %[[LAB3]]
// MCDC-DAG: store i32 %[[LAB4]], ptr %mcdc.addr, align 4
// SHIFT THIRD CONDITION WITH ID = 1.
// MCDC: %[[LAB1:[0-9]+]] = load i32, ptr %c.addr, align 4
// MCDC-DAG: %[[BOOL:tobool[0-9]*]] = icmp ne i32 %[[LAB1]], 0
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC-DAG: %[[LAB2:[0-9]+]] = zext i1 %[[BOOL]] to i32
// MCDC-DAG: %[[LAB3:[0-9]+]] = shl i32 %[[LAB2]], 1
// MCDC-DAG: %[[LAB4:[0-9]+]] = or i32 %[[TEMP]], %[[LAB3]]
// MCDC-DAG: store i32 %[[LAB4]], ptr %mcdc.addr, align 4
// SHIFT FOURTH CONDITION WITH ID = 4.
// MCDC: %[[LAB1:[0-9]+]] = load i32, ptr %d.addr, align 4
// MCDC-DAG: %[[BOOL:tobool[0-9]*]] = icmp ne i32 %[[LAB1]], 0
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC-DAG: %[[LAB2:[0-9]+]] = zext i1 %[[BOOL]] to i32
// MCDC-DAG: %[[LAB3:[0-9]+]] = shl i32 %[[LAB2]], 4
// MCDC-DAG: %[[LAB4:[0-9]+]] = or i32 %[[TEMP]], %[[LAB3]]
// MCDC-DAG: store i32 %[[LAB4]], ptr %mcdc.addr, align 4
// SHIFT FIFTH CONDITION WITH ID = 3.
// MCDC: %[[LAB1:[0-9]+]] = load i32, ptr %e.addr, align 4
// MCDC-DAG: %[[BOOL:tobool[0-9]*]] = icmp ne i32 %[[LAB1]], 0
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC-DAG: %[[LAB2:[0-9]+]] = zext i1 %[[BOOL]] to i32
// MCDC-DAG: %[[LAB3:[0-9]+]] = shl i32 %[[LAB2]], 3
// MCDC-DAG: %[[LAB4:[0-9]+]] = or i32 %[[TEMP]], %[[LAB3]]
// MCDC-DAG: store i32 %[[LAB4]], ptr %mcdc.addr, align 4
// SHIFT SIXTH CONDITION WITH ID = 5.
// MCDC: %[[LAB1:[0-9]+]] = load i32, ptr %f.addr, align 4
// MCDC-DAG: %[[BOOL:tobool[0-9]*]] = icmp ne i32 %[[LAB1]], 0
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC-DAG: %[[LAB2:[0-9]+]] = zext i1 %[[BOOL]] to i32
// MCDC-DAG: %[[LAB3:[0-9]+]] = shl i32 %[[LAB2]], 5
// MCDC-DAG: %[[LAB4:[0-9]+]] = or i32 %[[TEMP]], %[[LAB3]]
// MCDC-DAG: store i32 %[[LAB4]], ptr %mcdc.addr, align 4
// UPDATE FINAL BITMASK WITH RESULT.
// MCDC-DAG: %[[TEMP:mcdc.temp[0-9]*]] = load i32, ptr %mcdc.addr, align 4
// MCDC: %[[LAB1:[0-9]+]] = lshr i32 %[[TEMP]], 3
// MCDC: %[[LAB2:[0-9]+]] = zext i32 %[[LAB1]] to i64
// MCDC: %[[LAB3:[0-9]+]] = add i64 ptrtoint (ptr @__profbm_test to i64), %[[LAB2]]
// MCDC: %[[LAB4:[0-9]+]] = inttoptr i64 %[[LAB3]] to ptr
// MCDC: %[[LAB5:[0-9]+]] = and i32 %[[TEMP]], 7
// MCDC: %[[LAB6:[0-9]+]] = trunc i32 %[[LAB5]] to i8
// MCDC: %[[LAB7:[0-9]+]] = shl i8 1, %[[LAB6]]
// MCDC: %mcdc.bits = load i8, ptr %[[LAB4]], align 1
// MCDC: %[[LAB8:[0-9]+]] = or i8 %mcdc.bits, %[[LAB7]]
// MCDC: store i8 %[[LAB8]], ptr %[[LAB4]], align 1

compiler-rt/include/profile/InstrProfData.inc

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
#endif #endif
INSTR_PROF_DATA(const uint64_t, llvm::Type::getInt64Ty(Ctx), NameRef, \ INSTR_PROF_DATA(const uint64_t, llvm::Type::getInt64Ty(Ctx), NameRef, \
ConstantInt::get(llvm::Type::getInt64Ty(Ctx), \ ConstantInt::get(llvm::Type::getInt64Ty(Ctx), \
IndexedInstrProf::ComputeHash(getPGOFuncNameVarInitializer(Inc->getName())))) IndexedInstrProf::ComputeHash(getPGOFuncNameVarInitializer(Inc->getName()))))
INSTR_PROF_DATA(const uint64_t, llvm::Type::getInt64Ty(Ctx), FuncHash, \ INSTR_PROF_DATA(const uint64_t, llvm::Type::getInt64Ty(Ctx), FuncHash, \
ConstantInt::get(llvm::Type::getInt64Ty(Ctx), \ ConstantInt::get(llvm::Type::getInt64Ty(Ctx), \
Inc->getHash()->getZExtValue())) Inc->getHash()->getZExtValue()))
INSTR_PROF_DATA(const IntPtrT, IntPtrTy, CounterPtr, RelativeCounterPtr) INSTR_PROF_DATA(const IntPtrT, IntPtrTy, CounterPtr, RelativeCounterPtr)
INSTR_PROF_DATA(const IntPtrT, IntPtrTy, BitmaskPtr, RelativeBitmaskPtr)
/* This is used to map function pointers for the indirect call targets to /* This is used to map function pointers for the indirect call targets to
* function name hashes during the conversion from raw to merged profile * function name hashes during the conversion from raw to merged profile
* data. * data.
*/ */
INSTR_PROF_DATA(const IntPtrT, llvm::Type::getInt8PtrTy(Ctx), FunctionPointer, \ INSTR_PROF_DATA(const IntPtrT, llvm::Type::getInt8PtrTy(Ctx), FunctionPointer, \
FunctionAddr) FunctionAddr)
INSTR_PROF_DATA(IntPtrT, llvm::Type::getInt8PtrTy(Ctx), Values, \ INSTR_PROF_DATA(IntPtrT, llvm::Type::getInt8PtrTy(Ctx), Values, \
ValuesPtrExpr) ValuesPtrExpr)
INSTR_PROF_DATA(const uint32_t, llvm::Type::getInt32Ty(Ctx), NumCounters, \ INSTR_PROF_DATA(const uint32_t, llvm::Type::getInt32Ty(Ctx), NumCounters, \
ConstantInt::get(llvm::Type::getInt32Ty(Ctx), NumCounters)) ConstantInt::get(llvm::Type::getInt32Ty(Ctx), NumCounters))
INSTR_PROF_DATA(const uint16_t, Int16ArrayTy, NumValueSites[IPVK_Last+1], \ INSTR_PROF_DATA(const uint16_t, Int16ArrayTy, NumValueSites[IPVK_Last+1], \
ConstantArray::get(Int16ArrayTy, Int16ArrayVals)) ConstantArray::get(Int16ArrayTy, Int16ArrayVals)) \
INSTR_PROF_DATA(const uint32_t, llvm::Type::getInt32Ty(Ctx), NumBitmaskBytes, \
ConstantInt::get(llvm::Type::getInt32Ty(Ctx), NumBitmaskBytes))
#undef INSTR_PROF_DATA #undef INSTR_PROF_DATA
/* INSTR_PROF_DATA end. */ /* INSTR_PROF_DATA end. */
/* This is an internal data structure used by value profiler. It /* This is an internal data structure used by value profiler. It
* is defined here to allow serialization code sharing by LLVM * is defined here to allow serialization code sharing by LLVM
* to be used in unit test. * to be used in unit test.
* *
Show All 30 Lines
INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version()) INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version())
INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL)) INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL))
/* FIXME: A more accurate name is NumData */ /* FIXME: A more accurate name is NumData */
INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize) INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize)
INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesBeforeCounters, PaddingBytesBeforeCounters) INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesBeforeCounters, PaddingBytesBeforeCounters)
/* FIXME: A more accurate name is NumCounters */ /* FIXME: A more accurate name is NumCounters */
INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize) INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize)
INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesAfterCounters, PaddingBytesAfterCounters) INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesAfterCounters, PaddingBytesAfterCounters)
INSTR_PROF_RAW_HEADER(uint64_t, NumBitmaskBytes, NumBitmaskBytes)
INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesAfterBitmaskBytes, PaddingBytesAfterBitmaskBytes)
INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize) INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize)
INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta,
(uintptr_t)CountersBegin - (uintptr_t)DataBegin) (uintptr_t)CountersBegin - (uintptr_t)DataBegin)
INSTR_PROF_RAW_HEADER(uint64_t, BitmaskDelta,
(uintptr_t)BitmaskBegin - (uintptr_t)DataBegin)
INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin) INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin)
INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last) INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last)
#undef INSTR_PROF_RAW_HEADER #undef INSTR_PROF_RAW_HEADER
/* INSTR_PROF_RAW_HEADER end */ /* INSTR_PROF_RAW_HEADER end */
/* VALUE_PROF_FUNC_PARAM start */ /* VALUE_PROF_FUNC_PARAM start */
/* Definition of parameter types of the runtime API used to do value profiling /* Definition of parameter types of the runtime API used to do value profiling
* for a given value site. * for a given value site.
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Lines
#ifdef INSTR_PROF_SECT_ENTRY #ifdef INSTR_PROF_SECT_ENTRY
#define INSTR_PROF_DATA_DEFINED #define INSTR_PROF_DATA_DEFINED
INSTR_PROF_SECT_ENTRY(IPSK_data, \ INSTR_PROF_SECT_ENTRY(IPSK_data, \
INSTR_PROF_QUOTE(INSTR_PROF_DATA_COMMON), \ INSTR_PROF_QUOTE(INSTR_PROF_DATA_COMMON), \
INSTR_PROF_DATA_COFF, "__DATA,") INSTR_PROF_DATA_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_cnts, \ INSTR_PROF_SECT_ENTRY(IPSK_cnts, \
INSTR_PROF_QUOTE(INSTR_PROF_CNTS_COMMON), \ INSTR_PROF_QUOTE(INSTR_PROF_CNTS_COMMON), \
INSTR_PROF_CNTS_COFF, "__DATA,") INSTR_PROF_CNTS_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_bitmask, \
INSTR_PROF_QUOTE(INSTR_PROF_BITS_COMMON), \
INSTR_PROF_BITS_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_name, \ INSTR_PROF_SECT_ENTRY(IPSK_name, \
INSTR_PROF_QUOTE(INSTR_PROF_NAME_COMMON), \ INSTR_PROF_QUOTE(INSTR_PROF_NAME_COMMON), \
INSTR_PROF_NAME_COFF, "__DATA,") INSTR_PROF_NAME_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_vals, \ INSTR_PROF_SECT_ENTRY(IPSK_vals, \
INSTR_PROF_QUOTE(INSTR_PROF_VALS_COMMON), \ INSTR_PROF_QUOTE(INSTR_PROF_VALS_COMMON), \
INSTR_PROF_VALS_COFF, "__DATA,") INSTR_PROF_VALS_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_vnodes, \ INSTR_PROF_SECT_ENTRY(IPSK_vnodes, \
INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COMMON), \ INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COMMON), \
▲ Show 20 Lines • Show All 365 Lines • ▼ Show 20 Lines
#define INSTR_PROF_RAW_MAGIC_32 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \ #define INSTR_PROF_RAW_MAGIC_32 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \
(uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 | \ (uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 | \
(uint64_t)'f' << 16 | (uint64_t)'R' << 8 | (uint64_t)129 (uint64_t)'f' << 16 | (uint64_t)'R' << 8 | (uint64_t)129
/* FIXME: Please remedy the fixme in the header before bumping the version. */ /* FIXME: Please remedy the fixme in the header before bumping the version. */
/* Raw profile format version (start from 1). */ /* Raw profile format version (start from 1). */
#define INSTR_PROF_RAW_VERSION 8 #define INSTR_PROF_RAW_VERSION 8
/* Indexed profile format version (start from 1). */ /* Indexed profile format version (start from 1). */
#define INSTR_PROF_INDEX_VERSION 8 #define INSTR_PROF_INDEX_VERSION 9
/* Coverage mapping format version (start from 0). */ /* Coverage mapping format version (start from 0). */
#define INSTR_PROF_COVMAP_VERSION 5 #define INSTR_PROF_COVMAP_VERSION 6
/* Profile version is always of type uint64_t. Reserve the upper 8 bits in the /* Profile version is always of type uint64_t. Reserve the upper 8 bits in the
* version for other variants of profile. We set the lowest bit of the upper 8 * version for other variants of profile. We set the lowest bit of the upper 8
* bits (i.e. bit 56) to 1 to indicate if this is an IR-level instrumentation * bits (i.e. bit 56) to 1 to indicate if this is an IR-level instrumentation
* generated profile, and 0 if this is a Clang FE generated profile. * generated profile, and 0 if this is a Clang FE generated profile.
* 1 in bit 57 indicates there are context-sensitive records in the profile. * 1 in bit 57 indicates there are context-sensitive records in the profile.
* The 59th bit indicates whether to use debug info to correlate profiles. * The 59th bit indicates whether to use debug info to correlate profiles.
* The 60th bit indicates single byte coverage instrumentation. * The 60th bit indicates single byte coverage instrumentation.
Show All 17 Lines
* specified via command line. */ * specified via command line. */
#define INSTR_PROF_PROFILE_NAME_VAR __llvm_profile_filename #define INSTR_PROF_PROFILE_NAME_VAR __llvm_profile_filename
/* section name strings common to all targets other /* section name strings common to all targets other
than WIN32 */ than WIN32 */
#define INSTR_PROF_DATA_COMMON __llvm_prf_data #define INSTR_PROF_DATA_COMMON __llvm_prf_data
#define INSTR_PROF_NAME_COMMON __llvm_prf_names #define INSTR_PROF_NAME_COMMON __llvm_prf_names
#define INSTR_PROF_CNTS_COMMON __llvm_prf_cnts #define INSTR_PROF_CNTS_COMMON __llvm_prf_cnts
#define INSTR_PROF_BITS_COMMON __llvm_prf_bits
#define INSTR_PROF_VALS_COMMON __llvm_prf_vals #define INSTR_PROF_VALS_COMMON __llvm_prf_vals
#define INSTR_PROF_VNODES_COMMON __llvm_prf_vnds #define INSTR_PROF_VNODES_COMMON __llvm_prf_vnds
#define INSTR_PROF_COVMAP_COMMON __llvm_covmap #define INSTR_PROF_COVMAP_COMMON __llvm_covmap
#define INSTR_PROF_COVFUN_COMMON __llvm_covfun #define INSTR_PROF_COVFUN_COMMON __llvm_covfun
#define INSTR_PROF_ORDERFILE_COMMON __llvm_orderfile #define INSTR_PROF_ORDERFILE_COMMON __llvm_orderfile
/* Windows section names. Because these section names contain dollar characters, /* Windows section names. Because these section names contain dollar characters,
* they must be quoted. * they must be quoted.
*/ */
#define INSTR_PROF_DATA_COFF ".lprfd$M" #define INSTR_PROF_DATA_COFF ".lprfd$M"
#define INSTR_PROF_NAME_COFF ".lprfn$M" #define INSTR_PROF_NAME_COFF ".lprfn$M"
#define INSTR_PROF_CNTS_COFF ".lprfc$M" #define INSTR_PROF_CNTS_COFF ".lprfc$M"
#define INSTR_PROF_BITS_COFF ".lprfb$M"
#define INSTR_PROF_VALS_COFF ".lprfv$M" #define INSTR_PROF_VALS_COFF ".lprfv$M"
#define INSTR_PROF_VNODES_COFF ".lprfnd$M" #define INSTR_PROF_VNODES_COFF ".lprfnd$M"
#define INSTR_PROF_COVMAP_COFF ".lcovmap$M" #define INSTR_PROF_COVMAP_COFF ".lcovmap$M"
#define INSTR_PROF_COVFUN_COFF ".lcovfun$M" #define INSTR_PROF_COVFUN_COFF ".lcovfun$M"
#define INSTR_PROF_ORDERFILE_COFF ".lorderfile$M" #define INSTR_PROF_ORDERFILE_COFF ".lorderfile$M"
#ifdef _WIN32 #ifdef _WIN32
/* Runtime section names and name strings. */ /* Runtime section names and name strings. */
#define INSTR_PROF_DATA_SECT_NAME INSTR_PROF_DATA_COFF #define INSTR_PROF_DATA_SECT_NAME INSTR_PROF_DATA_COFF
#define INSTR_PROF_NAME_SECT_NAME INSTR_PROF_NAME_COFF #define INSTR_PROF_NAME_SECT_NAME INSTR_PROF_NAME_COFF
#define INSTR_PROF_CNTS_SECT_NAME INSTR_PROF_CNTS_COFF #define INSTR_PROF_CNTS_SECT_NAME INSTR_PROF_CNTS_COFF
#define INSTR_PROF_BITS_SECT_NAME INSTR_PROF_BITS_COFF
/* Array of pointers. Each pointer points to a list /* Array of pointers. Each pointer points to a list
* of value nodes associated with one value site. * of value nodes associated with one value site.
*/ */
#define INSTR_PROF_VALS_SECT_NAME INSTR_PROF_VALS_COFF #define INSTR_PROF_VALS_SECT_NAME INSTR_PROF_VALS_COFF
/* Value profile nodes section. */ /* Value profile nodes section. */
#define INSTR_PROF_VNODES_SECT_NAME INSTR_PROF_VNODES_COFF #define INSTR_PROF_VNODES_SECT_NAME INSTR_PROF_VNODES_COFF
#define INSTR_PROF_COVMAP_SECT_NAME INSTR_PROF_COVMAP_COFF #define INSTR_PROF_COVMAP_SECT_NAME INSTR_PROF_COVMAP_COFF
#define INSTR_PROF_COVFUN_SECT_NAME INSTR_PROF_COVFUN_COFF #define INSTR_PROF_COVFUN_SECT_NAME INSTR_PROF_COVFUN_COFF
#define INSTR_PROF_ORDERFILE_SECT_NAME INSTR_PROF_ORDERFILE_COFF #define INSTR_PROF_ORDERFILE_SECT_NAME INSTR_PROF_ORDERFILE_COFF
#else #else
/* Runtime section names and name strings. */ /* Runtime section names and name strings. */
#define INSTR_PROF_DATA_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_DATA_COMMON) #define INSTR_PROF_DATA_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_DATA_COMMON)
#define INSTR_PROF_NAME_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_NAME_COMMON) #define INSTR_PROF_NAME_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_NAME_COMMON)
#define INSTR_PROF_CNTS_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_CNTS_COMMON) #define INSTR_PROF_CNTS_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_CNTS_COMMON)
#define INSTR_PROF_BITS_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_BITS_COMMON)
/* Array of pointers. Each pointer points to a list /* Array of pointers. Each pointer points to a list
* of value nodes associated with one value site. * of value nodes associated with one value site.
*/ */
#define INSTR_PROF_VALS_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_VALS_COMMON) #define INSTR_PROF_VALS_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_VALS_COMMON)
/* Value profile nodes section. */ /* Value profile nodes section. */
#define INSTR_PROF_VNODES_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COMMON) #define INSTR_PROF_VNODES_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COMMON)
#define INSTR_PROF_COVMAP_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_COVMAP_COMMON) #define INSTR_PROF_COVMAP_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_COVMAP_COMMON)
#define INSTR_PROF_COVFUN_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_COVFUN_COMMON) #define INSTR_PROF_COVFUN_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_COVFUN_COMMON)
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

compiler-rt/lib/profile/InstrProfiling.h

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
int __llvm_profile_write_buffer(char *Buffer); int __llvm_profile_write_buffer(char *Buffer);
const __llvm_profile_data *__llvm_profile_begin_data(void); const __llvm_profile_data *__llvm_profile_begin_data(void);
const __llvm_profile_data *__llvm_profile_end_data(void); const __llvm_profile_data *__llvm_profile_end_data(void);
const char *__llvm_profile_begin_names(void); const char *__llvm_profile_begin_names(void);
const char *__llvm_profile_end_names(void); const char *__llvm_profile_end_names(void);
char *__llvm_profile_begin_counters(void); char *__llvm_profile_begin_counters(void);
char *__llvm_profile_end_counters(void); char *__llvm_profile_end_counters(void);
char *__llvm_profile_begin_bitmask(void);
char *__llvm_profile_end_bitmask(void);
ValueProfNode *__llvm_profile_begin_vnodes(); ValueProfNode *__llvm_profile_begin_vnodes();
ValueProfNode *__llvm_profile_end_vnodes(); ValueProfNode *__llvm_profile_end_vnodes();
uint32_t *__llvm_profile_begin_orderfile(); uint32_t *__llvm_profile_begin_orderfile();
/*! /*!
* \brief Clear profile counters to zero. * \brief Clear profile counters to zero.
* *
*/ */
void __llvm_profile_reset_counters(void); void __llvm_profile_reset_counters(void);
/*! /*!
* \brief Merge profile data from buffer. * \brief Merge profile data from buffer.
* *
* Read profile data form buffer \p Profile and merge with in-process profile * Read profile data form buffer \p Profile and merge with in-process profile
* counters. The client is expected to have checked or already knows the profile * counters and bitmasks. The client is expected to have checked or already
* data in the buffer matches the in-process counter structure before calling * knows the profile data in the buffer matches the in-process counter
* it. Returns 0 (success) if the profile data is valid. Upon reading * structure before calling it. Returns 0 (success) if the profile data is
* invalid/corrupted profile data, returns 1 (failure). * valid. Upon reading invalid/corrupted profile data, returns 1 (failure).
*/ */
int __llvm_profile_merge_from_buffer(const char *Profile, uint64_t Size); int __llvm_profile_merge_from_buffer(const char *Profile, uint64_t Size);
/*! \brief Check if profile in buffer matches the current binary. /*! \brief Check if profile in buffer matches the current binary.
* *
* Returns 0 (success) if the profile data in buffer \p Profile with size * Returns 0 (success) if the profile data in buffer \p Profile with size
* \p Size was generated by the same binary and therefore matches * \p Size was generated by the same binary and therefore matches
* structurally the in-process counters. If the profile data in buffer is * structurally the in-process counters and bitmasks. If the profile data in
* not compatible, the interface returns 1 (failure). * buffer is not compatible, the interface returns 1 (failure).
*/ */
int __llvm_profile_check_compatibility(const char *Profile, int __llvm_profile_check_compatibility(const char *Profile,
uint64_t Size); uint64_t Size);
/*! /*!
* \brief Counts the number of times a target value is seen. * \brief Counts the number of times a target value is seen.
* *
* Records the target value for the CounterIndex if not seen before. Otherwise, * Records the target value for the CounterIndex if not seen before. Otherwise,
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Lines
size_t __llvm_profile_counter_entry_size(void); size_t __llvm_profile_counter_entry_size(void);
/*! \brief Get the number of entries in the profile counters section. */ /*! \brief Get the number of entries in the profile counters section. */
uint64_t __llvm_profile_get_num_counters(const char *Begin, const char *End); uint64_t __llvm_profile_get_num_counters(const char *Begin, const char *End);
/*! \brief Get the size of the profile counters section in bytes. */ /*! \brief Get the size of the profile counters section in bytes. */
uint64_t __llvm_profile_get_counters_size(const char *Begin, const char *End); uint64_t __llvm_profile_get_counters_size(const char *Begin, const char *End);
/*! \brief Get the number of bytes in the profile bitmask section. */
uint64_t __llvm_profile_get_num_bitmask_bytes(const char *Begin, const char *End);
/* ! \brief Given the sizes of the data and counter information, return the /* ! \brief Given the sizes of the data and counter information, return the
* number of padding bytes before and after the counters, and after the names, * number of padding bytes before and after the counters, and after the names,
* in the raw profile. * in the raw profile.
* *
* Note: When mmap() mode is disabled, no padding bytes before/after counters * Note: When mmap() mode is disabled, no padding bytes before/after counters
* are needed. However, in mmap() mode, the counter section in the raw profile * are needed. However, in mmap() mode, the counter section in the raw profile
* must be page-aligned: this API computes the number of padding bytes * must be page-aligned: this API computes the number of padding bytes
* needed to achieve that. * needed to achieve that.
*/ */
void __llvm_profile_get_padding_sizes_for_counters( void __llvm_profile_get_padding_sizes_for_counters(
uint64_t DataSize, uint64_t CountersSize, uint64_t NamesSize, uint64_t DataSize, uint64_t CountersSize, uint64_t NumBitmaskBytes,
uint64_t *PaddingBytesBeforeCounters, uint64_t *PaddingBytesAfterCounters, uint64_t NamesSize, uint64_t *PaddingBytesBeforeCounters,
uint64_t *PaddingBytesAfterCounters, uint64_t *PaddingBytesAfterBitmask,
uint64_t *PaddingBytesAfterNames); uint64_t *PaddingBytesAfterNames);
/*! /*!
* \brief Set the flag that profile data has been dumped to the file. * \brief Set the flag that profile data has been dumped to the file.
* This is useful for users to disable dumping profile data to the file for * This is useful for users to disable dumping profile data to the file for
* certain processes in case the processes don't have permission to write to * certain processes in case the processes don't have permission to write to
* the disks, and trying to do so would result in side effects such as crashes. * the disks, and trying to do so would result in side effects such as crashes.
*/ */
Show All 31 Lines

compiler-rt/lib/profile/InstrProfiling.c

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
COMPILER_RT_VISIBILITY void __llvm_profile_reset_counters(void) { COMPILER_RT_VISIBILITY void __llvm_profile_reset_counters(void) {
char *I = __llvm_profile_begin_counters(); char *I = __llvm_profile_begin_counters();
char *E = __llvm_profile_end_counters(); char *E = __llvm_profile_end_counters();
char ResetValue = char ResetValue =
(__llvm_profile_get_version() & VARIANT_MASK_BYTE_COVERAGE) ? 0xFF : 0; (__llvm_profile_get_version() & VARIANT_MASK_BYTE_COVERAGE) ? 0xFF : 0;
memset(I, ResetValue, E - I); memset(I, ResetValue, E - I);
I = __llvm_profile_begin_bitmask();
E = __llvm_profile_end_bitmask();
memset(I, 0x0, E - I);
const __llvm_profile_data *DataBegin = __llvm_profile_begin_data(); const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
const __llvm_profile_data *DataEnd = __llvm_profile_end_data(); const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
const __llvm_profile_data *DI; const __llvm_profile_data *DI;
for (DI = DataBegin; DI < DataEnd; ++DI) { for (DI = DataBegin; DI < DataEnd; ++DI) {
uint64_t CurrentVSiteCount = 0; uint64_t CurrentVSiteCount = 0;
uint32_t VKI, i; uint32_t VKI, i;
if (!DI->Values) if (!DI->Values)
continue; continue;
Show All 17 Lines

compiler-rt/lib/profile/InstrProfilingBuffer.c

Show All 37 Lines
} }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
uint64_t __llvm_profile_get_size_for_buffer(void) { uint64_t __llvm_profile_get_size_for_buffer(void) {
const __llvm_profile_data *DataBegin = __llvm_profile_begin_data(); const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
const __llvm_profile_data *DataEnd = __llvm_profile_end_data(); const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
const char *CountersBegin = __llvm_profile_begin_counters(); const char *CountersBegin = __llvm_profile_begin_counters();
const char *CountersEnd = __llvm_profile_end_counters(); const char *CountersEnd = __llvm_profile_end_counters();
const char *BitmaskBegin = __llvm_profile_begin_bitmask();
const char *BitmaskEnd = __llvm_profile_end_bitmask();
const char *NamesBegin = __llvm_profile_begin_names(); const char *NamesBegin = __llvm_profile_begin_names();
const char *NamesEnd = __llvm_profile_end_names(); const char *NamesEnd = __llvm_profile_end_names();
return __llvm_profile_get_size_for_buffer_internal( return __llvm_profile_get_size_for_buffer_internal(
DataBegin, DataEnd, CountersBegin, CountersEnd, NamesBegin, NamesEnd); DataBegin, DataEnd, CountersBegin, CountersEnd, BitmaskBegin, BitmaskEnd,
NamesBegin, NamesEnd);
} }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
uint64_t __llvm_profile_get_num_data(const __llvm_profile_data *Begin, uint64_t __llvm_profile_get_num_data(const __llvm_profile_data *Begin,
const __llvm_profile_data *End) { const __llvm_profile_data *End) {
intptr_t BeginI = (intptr_t)Begin, EndI = (intptr_t)End; intptr_t BeginI = (intptr_t)Begin, EndI = (intptr_t)End;
return ((EndI + sizeof(__llvm_profile_data) - 1) - BeginI) / return ((EndI + sizeof(__llvm_profile_data) - 1) - BeginI) /
sizeof(__llvm_profile_data); sizeof(__llvm_profile_data);
Show All 19 Lines
} }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
uint64_t __llvm_profile_get_counters_size(const char *Begin, const char *End) { uint64_t __llvm_profile_get_counters_size(const char *Begin, const char *End) {
return __llvm_profile_get_num_counters(Begin, End) * return __llvm_profile_get_num_counters(Begin, End) *
__llvm_profile_counter_entry_size(); __llvm_profile_counter_entry_size();
} }
COMPILER_RT_VISIBILITY
uint64_t __llvm_profile_get_num_bitmask_bytes(const char *Begin, const char *End) {
return (End - Begin);
}
/// Calculate the number of padding bytes needed to add to \p Offset in order /// Calculate the number of padding bytes needed to add to \p Offset in order
/// for (\p Offset + Padding) to be page-aligned. /// for (\p Offset + Padding) to be page-aligned.
static uint64_t calculateBytesNeededToPageAlign(uint64_t Offset) { static uint64_t calculateBytesNeededToPageAlign(uint64_t Offset) {
uint64_t OffsetModPage = Offset % PageSize; uint64_t OffsetModPage = Offset % PageSize;
if (OffsetModPage > 0) if (OffsetModPage > 0)
return PageSize - OffsetModPage; return PageSize - OffsetModPage;
return 0; return 0;
} }
static int needsCounterPadding(void) { static int needsCounterPadding(void) {
#if defined(__APPLE__) #if defined(__APPLE__)
return __llvm_profile_is_continuous_mode_enabled(); return __llvm_profile_is_continuous_mode_enabled();
#else #else
return 0; return 0;
#endif #endif
} }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
void __llvm_profile_get_padding_sizes_for_counters( void __llvm_profile_get_padding_sizes_for_counters(
uint64_t DataSize, uint64_t CountersSize, uint64_t NamesSize, uint64_t DataSize, uint64_t CountersSize, uint64_t NumBitmaskBytes,
uint64_t *PaddingBytesBeforeCounters, uint64_t *PaddingBytesAfterCounters, uint64_t NamesSize, uint64_t *PaddingBytesBeforeCounters,
uint64_t *PaddingBytesAfterNames) { uint64_t *PaddingBytesAfterCounters,
uint64_t *PaddingBytesAfterBitmaskBytes, uint64_t *PaddingBytesAfterNames) {
if (!needsCounterPadding()) { if (!needsCounterPadding()) {
*PaddingBytesBeforeCounters = 0; *PaddingBytesBeforeCounters = 0;
*PaddingBytesAfterCounters = 0; *PaddingBytesAfterCounters = 0;
*PaddingBytesAfterBitmaskBytes = 0;
*PaddingBytesAfterNames = __llvm_profile_get_num_padding_bytes(NamesSize); *PaddingBytesAfterNames = __llvm_profile_get_num_padding_bytes(NamesSize);
return; return;
} }
// In continuous mode, the file offsets for headers and for the start of // In continuous mode, the file offsets for headers and for the start of
// counter sections need to be page-aligned. // counter sections need to be page-aligned.
*PaddingBytesBeforeCounters = *PaddingBytesBeforeCounters =
calculateBytesNeededToPageAlign(sizeof(__llvm_profile_header) + DataSize); calculateBytesNeededToPageAlign(sizeof(__llvm_profile_header) + DataSize);
*PaddingBytesAfterCounters = calculateBytesNeededToPageAlign(CountersSize); *PaddingBytesAfterCounters = calculateBytesNeededToPageAlign(CountersSize);
*PaddingBytesAfterBitmaskBytes =
calculateBytesNeededToPageAlign(NumBitmaskBytes);
*PaddingBytesAfterNames = calculateBytesNeededToPageAlign(NamesSize); *PaddingBytesAfterNames = calculateBytesNeededToPageAlign(NamesSize);
} }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
uint64_t __llvm_profile_get_size_for_buffer_internal( uint64_t __llvm_profile_get_size_for_buffer_internal(
const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd, const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
const char *CountersBegin, const char *CountersEnd, const char *NamesBegin, const char *CountersBegin, const char *CountersEnd,
const char *NamesEnd) { const char *BitmaskBegin, const char *BitmaskEnd,
const char *NamesBegin, const char *NamesEnd) {
/* Match logic in __llvm_profile_write_buffer(). */ /* Match logic in __llvm_profile_write_buffer(). */
const uint64_t NamesSize = (NamesEnd - NamesBegin) * sizeof(char); const uint64_t NamesSize = (NamesEnd - NamesBegin) * sizeof(char);
uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd); uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
uint64_t CountersSize = uint64_t CountersSize =
__llvm_profile_get_counters_size(CountersBegin, CountersEnd); __llvm_profile_get_counters_size(CountersBegin, CountersEnd);
const uint64_t NumBitmaskBytes =
__llvm_profile_get_num_bitmask_bytes(BitmaskBegin, BitmaskEnd);
/* Determine how much padding is needed before/after the counters and after /* Determine how much padding is needed before/after the counters and after
* the names. */ * the names. */
uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters, uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters,
PaddingBytesAfterNames; PaddingBytesAfterNames, PaddingBytesAfterBitmaskBytes;
__llvm_profile_get_padding_sizes_for_counters( __llvm_profile_get_padding_sizes_for_counters(
DataSize, CountersSize, NamesSize, &PaddingBytesBeforeCounters, DataSize, CountersSize, NumBitmaskBytes, NamesSize,
&PaddingBytesAfterCounters, &PaddingBytesAfterNames); &PaddingBytesBeforeCounters, &PaddingBytesAfterCounters,
&PaddingBytesAfterBitmaskBytes, &PaddingBytesAfterNames);
return sizeof(__llvm_profile_header) + __llvm_write_binary_ids(NULL) + return sizeof(__llvm_profile_header) + __llvm_write_binary_ids(NULL) +
DataSize + PaddingBytesBeforeCounters + CountersSize + DataSize + PaddingBytesBeforeCounters + CountersSize +
PaddingBytesAfterCounters + NamesSize + PaddingBytesAfterNames; PaddingBytesAfterCounters + NumBitmaskBytes +
PaddingBytesAfterBitmaskBytes + NamesSize + PaddingBytesAfterNames;
} }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
void initBufferWriter(ProfDataWriter *BufferWriter, char *Buffer) { void initBufferWriter(ProfDataWriter *BufferWriter, char *Buffer) {
BufferWriter->Write = lprofBufferWriter; BufferWriter->Write = lprofBufferWriter;
BufferWriter->WriterCtx = Buffer; BufferWriter->WriterCtx = Buffer;
} }
COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer(char *Buffer) { COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer(char *Buffer) {
ProfDataWriter BufferWriter; ProfDataWriter BufferWriter;
initBufferWriter(&BufferWriter, Buffer); initBufferWriter(&BufferWriter, Buffer);
return lprofWriteData(&BufferWriter, 0, 0); return lprofWriteData(&BufferWriter, 0, 0);
} }
COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer_internal( COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer_internal(
char *Buffer, const __llvm_profile_data *DataBegin, char *Buffer, const __llvm_profile_data *DataBegin,
const __llvm_profile_data *DataEnd, const char *CountersBegin, const __llvm_profile_data *DataEnd, const char *CountersBegin,
const char *CountersEnd, const char *NamesBegin, const char *NamesEnd) { const char *CountersEnd, const char *BitmaskBegin, const char *BitmaskEnd,
const char *NamesBegin, const char *NamesEnd) {
ProfDataWriter BufferWriter; ProfDataWriter BufferWriter;
initBufferWriter(&BufferWriter, Buffer); initBufferWriter(&BufferWriter, Buffer);
return lprofWriteDataImpl(&BufferWriter, DataBegin, DataEnd, CountersBegin, return lprofWriteDataImpl(&BufferWriter, DataBegin, DataEnd, CountersBegin,
CountersEnd, 0, NamesBegin, NamesEnd, 0); CountersEnd, BitmaskBegin, BitmaskEnd, 0,
NamesBegin, NamesEnd, 0);
} }

compiler-rt/lib/profile/InstrProfilingFile.c

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
static void *BiasDefaultAddr = NULL; static void *BiasDefaultAddr = NULL;
static int mmapForContinuousMode(uint64_t CurrentFileOffset, FILE *File) { static int mmapForContinuousMode(uint64_t CurrentFileOffset, FILE *File) {
/* Get the sizes of various profile data sections. Taken from /* Get the sizes of various profile data sections. Taken from
* __llvm_profile_get_size_for_buffer(). */ * __llvm_profile_get_size_for_buffer(). */
const __llvm_profile_data *DataBegin = __llvm_profile_begin_data(); const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
const __llvm_profile_data *DataEnd = __llvm_profile_end_data(); const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
const char *CountersBegin = __llvm_profile_begin_counters(); const char *CountersBegin = __llvm_profile_begin_counters();
const char *CountersEnd = __llvm_profile_end_counters(); const char *CountersEnd = __llvm_profile_end_counters();
const char *BitmaskBegin = __llvm_profile_begin_bitmask();
const char *BitmaskEnd = __llvm_profile_end_bitmask();
const char *NamesBegin = __llvm_profile_begin_names(); const char *NamesBegin = __llvm_profile_begin_names();
const char *NamesEnd = __llvm_profile_end_names(); const char *NamesEnd = __llvm_profile_end_names();
const uint64_t NamesSize = (NamesEnd - NamesBegin) * sizeof(char); const uint64_t NamesSize = (NamesEnd - NamesBegin) * sizeof(char);
uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd); uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
uint64_t CountersSize = uint64_t CountersSize =
__llvm_profile_get_counters_size(CountersBegin, CountersEnd); __llvm_profile_get_counters_size(CountersBegin, CountersEnd);
uint64_t NumBitmaskBytes =
__llvm_profile_get_num_bitmask_bytes(BitmaskBegin, BitmaskEnd);
/* Check that the counter and data sections in this image are /* Check that the counter, bitmask, and data sections in this image are
* page-aligned. */ * page-aligned. */
unsigned PageSize = getpagesize(); unsigned PageSize = getpagesize();
if ((intptr_t)CountersBegin % PageSize != 0) { if ((intptr_t)CountersBegin % PageSize != 0) {
PROF_ERR("Counters section not page-aligned (start = %p, pagesz = %u).\n", PROF_ERR("Counters section not page-aligned (start = %p, pagesz = %u).\n",
CountersBegin, PageSize); CountersBegin, PageSize);
return 1; return 1;
} }
if ((intptr_t)BitmaskBegin % PageSize != 0) {
PROF_ERR("Bitmask section not page-aligned (start = %p, pagesz = %u).\n",
BitmaskBegin, PageSize);
return 1;
}
if ((intptr_t)DataBegin % PageSize != 0) { if ((intptr_t)DataBegin % PageSize != 0) {
PROF_ERR("Data section not page-aligned (start = %p, pagesz = %u).\n", PROF_ERR("Data section not page-aligned (start = %p, pagesz = %u).\n",
DataBegin, PageSize); DataBegin, PageSize);
return 1; return 1;
} }
int Fileno = fileno(File); int Fileno = fileno(File);
/* Determine how much padding is needed before/after the counters and /* Determine how much padding is needed before/after the counters and
* after the names. */ * after the names. */
uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters, uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters,
PaddingBytesAfterNames; PaddingBytesAfterNames, PaddingBytesAfterBitmaskBytes;
__llvm_profile_get_padding_sizes_for_counters( __llvm_profile_get_padding_sizes_for_counters(
DataSize, CountersSize, NamesSize, &PaddingBytesBeforeCounters, DataSize, CountersSize, NumBitmaskBytes, NamesSize,
&PaddingBytesAfterCounters, &PaddingBytesAfterNames); &PaddingBytesBeforeCounters, &PaddingBytesAfterCounters,
&PaddingBytesAfterBitmaskBytes, &PaddingBytesAfterNames);
uint64_t PageAlignedCountersLength = CountersSize + PaddingBytesAfterCounters; uint64_t PageAlignedCountersLength = CountersSize + PaddingBytesAfterCounters;
uint64_t FileOffsetToCounters = CurrentFileOffset + uint64_t FileOffsetToCounters = CurrentFileOffset +
sizeof(__llvm_profile_header) + DataSize + sizeof(__llvm_profile_header) + DataSize +
PaddingBytesBeforeCounters; PaddingBytesBeforeCounters;
void *CounterMmap = mmap((void *)CountersBegin, PageAlignedCountersLength, void *CounterMmap = mmap((void *)CountersBegin, PageAlignedCountersLength,
PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED,
Fileno, FileOffsetToCounters); Fileno, FileOffsetToCounters);
if (CounterMmap != CountersBegin) { if (CounterMmap != CountersBegin) {
PROF_ERR( PROF_ERR(
"Continuous counter sync mode is enabled, but mmap() failed (%s).\n" "Continuous counter sync mode is enabled, but mmap() failed (%s).\n"
" - CountersBegin: %p\n" " - CountersBegin: %p\n"
" - PageAlignedCountersLength: %" PRIu64 "\n" " - PageAlignedCountersLength: %" PRIu64 "\n"
" - Fileno: %d\n" " - Fileno: %d\n"
" - FileOffsetToCounters: %" PRIu64 "\n", " - FileOffsetToCounters: %" PRIu64 "\n",
strerror(errno), CountersBegin, PageAlignedCountersLength, Fileno, strerror(errno), CountersBegin, PageAlignedCountersLength, Fileno,
FileOffsetToCounters); FileOffsetToCounters);
return 1; return 1;
} }
/* Also mmap MCDC bitmask bytes. If there aren't any bitmask bytes, mmap()
* will fail with EINVAL. */
if (NumBitmaskBytes == 0)
return 0;
uint64_t PageAlignedBitmaskLength = NumBitmaskBytes +
PaddingBytesAfterBitmaskBytes;
uint64_t FileOffsetToBitmask = CurrentFileOffset +
sizeof(__llvm_profile_header) + DataSize +
PaddingBytesBeforeCounters + CountersSize +
PaddingBytesAfterCounters;
void *BitmaskMmap = mmap((void *)BitmaskBegin, PageAlignedBitmaskLength,
PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED,
Fileno, FileOffsetToBitmask);
if (BitmaskMmap != BitmaskBegin) {
PROF_ERR(
"Continuous counter sync mode is enabled, but mmap() failed (%s).\n"
" - BitmaskBegin: %p\n"
" - PageAlignedBitmaskLength: %" PRIu64 "\n"
" - Fileno: %d\n"
" - FileOffsetToBitmask: %" PRIu64 "\n",
strerror(errno), BitmaskBegin, PageAlignedBitmaskLength, Fileno,
FileOffsetToBitmask);
return 1;
}
return 0; return 0;
} }
#elif defined(__ELF__) || defined(_WIN32) #elif defined(__ELF__) || defined(_WIN32)
#define INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR \ #define INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR \
INSTR_PROF_CONCAT(INSTR_PROF_PROFILE_COUNTER_BIAS_VAR, _default) INSTR_PROF_CONCAT(INSTR_PROF_PROFILE_COUNTER_BIAS_VAR, _default)
COMPILER_RT_VISIBILITY intptr_t INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR = 0; COMPILER_RT_VISIBILITY intptr_t INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR = 0;
Show All 26 Lines
static void *BiasDefaultAddr = &INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR; static void *BiasDefaultAddr = &INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR;
static int mmapForContinuousMode(uint64_t CurrentFileOffset, FILE *File) { static int mmapForContinuousMode(uint64_t CurrentFileOffset, FILE *File) {
/* Get the sizes of various profile data sections. Taken from /* Get the sizes of various profile data sections. Taken from
* __llvm_profile_get_size_for_buffer(). */ * __llvm_profile_get_size_for_buffer(). */
const __llvm_profile_data *DataBegin = __llvm_profile_begin_data(); const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
const __llvm_profile_data *DataEnd = __llvm_profile_end_data(); const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
const char *CountersBegin = __llvm_profile_begin_counters(); const char *CountersBegin = __llvm_profile_begin_counters();
const char *CountersEnd = __llvm_profile_end_counters(); const char *CountersEnd = __llvm_profile_end_counters();
const char *BitmaskBegin = __llvm_profile_begin_bitmask();
const char *BitmaskEnd = __llvm_profile_end_bitmask();
uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd); uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
/* Get the file size. */ /* Get the file size. */
uint64_t FileSize = 0; uint64_t FileSize = 0;
if (getProfileFileSizeForMerging(File, &FileSize)) if (getProfileFileSizeForMerging(File, &FileSize))
return 1; return 1;
/* Map the profile. */ /* Map the profile. */
char *Profile = (char *)mmap(NULL, FileSize, PROT_READ | PROT_WRITE, char *Profile = (char *)mmap(NULL, FileSize, PROT_READ | PROT_WRITE,
MAP_SHARED, fileno(File), 0); MAP_SHARED, fileno(File), 0);
if (Profile == MAP_FAILED) { if (Profile == MAP_FAILED) {
PROF_ERR("Unable to mmap profile: %s\n", strerror(errno)); PROF_ERR("Unable to mmap profile: %s\n", strerror(errno));
return 1; return 1;
} }
const uint64_t CountersOffsetInBiasMode = const uint64_t CountersOffsetInBiasMode =
sizeof(__llvm_profile_header) + __llvm_write_binary_ids(NULL) + DataSize; sizeof(__llvm_profile_header) + __llvm_write_binary_ids(NULL) + DataSize;
/* Update the profile fields based on the current mapping. */ /* Update the profile fields based on the current mapping. */
INSTR_PROF_PROFILE_COUNTER_BIAS_VAR = INSTR_PROF_PROFILE_COUNTER_BIAS_VAR =
(intptr_t)Profile - (uintptr_t)CountersBegin + CountersOffsetInBiasMode; (intptr_t)Profile - (uintptr_t)CountersBegin + CountersOffsetInBiasMode;
/* Return the memory allocated for counters to OS. */ /* Return the memory allocated for counters to OS. */
lprofReleaseMemoryPagesToOS((uintptr_t)CountersBegin, (uintptr_t)CountersEnd); lprofReleaseMemoryPagesToOS((uintptr_t)CountersBegin, (uintptr_t)CountersEnd);
/* BIAS MODE not supported yet for Bitmask (MCDC). */
/* Return the memory allocated for counters to OS. */
lprofReleaseMemoryPagesToOS((uintptr_t)BitmaskBegin, (uintptr_t)BitmaskEnd);
return 0; return 0;
} }
#else #else
static const int ContinuousModeSupported = 0; static const int ContinuousModeSupported = 0;
static const int UseBiasVar = 0; static const int UseBiasVar = 0;
static const char *FileOpenMode = "a+b"; static const char *FileOpenMode = "a+b";
static void *BiasAddr = NULL; static void *BiasAddr = NULL;
static void *BiasDefaultAddr = NULL; static void *BiasDefaultAddr = NULL;
▲ Show 20 Lines • Show All 966 Lines • Show Last 20 Lines

compiler-rt/lib/profile/InstrProfilingInternal.h

Show All 15 Lines
/*! /*!
* \brief Write instrumentation data to the given buffer, given explicit * \brief Write instrumentation data to the given buffer, given explicit
* pointers to the live data in memory. This function is probably not what you * pointers to the live data in memory. This function is probably not what you
* want. Use __llvm_profile_get_size_for_buffer instead. Use this function if * want. Use __llvm_profile_get_size_for_buffer instead. Use this function if
* your program has a custom memory layout. * your program has a custom memory layout.
*/ */
uint64_t __llvm_profile_get_size_for_buffer_internal( uint64_t __llvm_profile_get_size_for_buffer_internal(
const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd, const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
const char *CountersBegin, const char *CountersEnd, const char *NamesBegin, const char *CountersBegin, const char *CountersEnd,
const char *BitmaskBegin, const char *BitmaskEnd, const char *NamesBegin,
const char *NamesEnd); const char *NamesEnd);
/*! /*!
* \brief Write instrumentation data to the given buffer, given explicit * \brief Write instrumentation data to the given buffer, given explicit
* pointers to the live data in memory. This function is probably not what you * pointers to the live data in memory. This function is probably not what you
* want. Use __llvm_profile_write_buffer instead. Use this function if your * want. Use __llvm_profile_write_buffer instead. Use this function if your
* program has a custom memory layout. * program has a custom memory layout.
* *
* \pre \c Buffer is the start of a buffer at least as big as \a * \pre \c Buffer is the start of a buffer at least as big as \a
* __llvm_profile_get_size_for_buffer_internal(). * __llvm_profile_get_size_for_buffer_internal().
*/ */
int __llvm_profile_write_buffer_internal( int __llvm_profile_write_buffer_internal(
char *Buffer, const __llvm_profile_data *DataBegin, char *Buffer, const __llvm_profile_data *DataBegin,
const __llvm_profile_data *DataEnd, const char *CountersBegin, const __llvm_profile_data *DataEnd, const char *CountersBegin,
const char *CountersEnd, const char *NamesBegin, const char *NamesEnd); const char *CountersEnd, const char *BitmaskBegin, const char *BitmaskEnd,
const char *NamesBegin, const char *NamesEnd);
/*! /*!
* The data structure describing the data to be written by the * The data structure describing the data to be written by the
* low level writer callback function. * low level writer callback function.
* *
* If \ref ProfDataIOVec.Data is null, and \ref ProfDataIOVec.UseZeroPadding is * If \ref ProfDataIOVec.Data is null, and \ref ProfDataIOVec.UseZeroPadding is
* 0, the write is skipped (the writer simply advances ElmSize*NumElm bytes). * 0, the write is skipped (the writer simply advances ElmSize*NumElm bytes).
* *
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
/* Write profile data to destination. If SkipNameDataWrite is set to 1, /* Write profile data to destination. If SkipNameDataWrite is set to 1,
the name data is already in destination, we just skip over it. */ the name data is already in destination, we just skip over it. */
int lprofWriteData(ProfDataWriter *Writer, VPDataReaderType *VPDataReader, int lprofWriteData(ProfDataWriter *Writer, VPDataReaderType *VPDataReader,
int SkipNameDataWrite); int SkipNameDataWrite);
int lprofWriteDataImpl(ProfDataWriter *Writer, int lprofWriteDataImpl(ProfDataWriter *Writer,
const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataBegin,
const __llvm_profile_data *DataEnd, const __llvm_profile_data *DataEnd,
const char *CountersBegin, const char *CountersEnd, const char *CountersBegin, const char *CountersEnd,
const char *BitmaskBegin, const char *BitmaskEnd,
VPDataReaderType *VPDataReader, const char *NamesBegin, VPDataReaderType *VPDataReader, const char *NamesBegin,
const char *NamesEnd, int SkipNameDataWrite); const char *NamesEnd, int SkipNameDataWrite);
/* Merge value profile data pointed to by SrcValueProfData into /* Merge value profile data pointed to by SrcValueProfData into
* in-memory profile counters pointed by to DstData. */ * in-memory profile counters pointed by to DstData. */
void lprofMergeValueProfData(struct ValueProfData *SrcValueProfData, void lprofMergeValueProfData(struct ValueProfData *SrcValueProfData,
__llvm_profile_data *DstData); __llvm_profile_data *DstData);
Show All 38 Lines

compiler-rt/lib/profile/InstrProfilingMerge.c

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Linesint __llvm_profile_check_compatibility(const char *ProfileData,
if (Header->Magic != __llvm_profile_get_magic() || if (Header->Magic != __llvm_profile_get_magic() ||
Header->Version != __llvm_profile_get_version() || Header->Version != __llvm_profile_get_version() ||
Header->DataSize != Header->DataSize !=
__llvm_profile_get_num_data(__llvm_profile_begin_data(), __llvm_profile_get_num_data(__llvm_profile_begin_data(),
__llvm_profile_end_data()) || __llvm_profile_end_data()) ||
Header->CountersSize != Header->CountersSize !=
__llvm_profile_get_num_counters(__llvm_profile_begin_counters(), __llvm_profile_get_num_counters(__llvm_profile_begin_counters(),
__llvm_profile_end_counters()) || __llvm_profile_end_counters()) ||
Header->NumBitmaskBytes !=
__llvm_profile_get_num_bitmask_bytes(__llvm_profile_begin_bitmask(),
__llvm_profile_end_bitmask()) ||
Header->NamesSize != (uint64_t)(__llvm_profile_end_names() - Header->NamesSize != (uint64_t)(__llvm_profile_end_names() -
__llvm_profile_begin_names()) || __llvm_profile_begin_names()) ||
Header->ValueKindLast != IPVK_Last) Header->ValueKindLast != IPVK_Last)
return 1; return 1;
if (ProfileSize < if (ProfileSize <
sizeof(__llvm_profile_header) + Header->BinaryIdsSize + sizeof(__llvm_profile_header) + Header->BinaryIdsSize +
Header->DataSize * sizeof(__llvm_profile_data) + Header->NamesSize + Header->DataSize * sizeof(__llvm_profile_data) + Header->NamesSize +
Header->CountersSize * __llvm_profile_counter_entry_size()) Header->CountersSize * __llvm_profile_counter_entry_size() +
Header->NumBitmaskBytes)
return 1; return 1;
for (SrcData = SrcDataStart, for (SrcData = SrcDataStart,
DstData = (__llvm_profile_data *)__llvm_profile_begin_data(); DstData = (__llvm_profile_data *)__llvm_profile_begin_data();
SrcData < SrcDataEnd; ++SrcData, ++DstData) { SrcData < SrcDataEnd; ++SrcData, ++DstData) {
if (SrcData->NameRef != DstData->NameRef || if (SrcData->NameRef != DstData->NameRef ||
SrcData->FuncHash != DstData->FuncHash || SrcData->FuncHash != DstData->FuncHash ||
SrcData->NumCounters != DstData->NumCounters) SrcData->NumCounters != DstData->NumCounters ||
SrcData->NumBitmaskBytes != DstData->NumBitmaskBytes)
return 1; return 1;
} }
/* Matched! */ /* Matched! */
return 0; return 0;
} }
static uintptr_t signextIfWin64(void *V) { static uintptr_t signextIfWin64(void *V) {
Show All 13 Lines PROF_ERR(
"Debug info correlation does not support profile merging at runtime. " "Debug info correlation does not support profile merging at runtime. "
"Instead, merge raw profiles using the llvm-profdata tool."); "Instead, merge raw profiles using the llvm-profdata tool.");
return 1; return 1;
} }
__llvm_profile_data *SrcDataStart, *SrcDataEnd, *SrcData, *DstData; __llvm_profile_data *SrcDataStart, *SrcDataEnd, *SrcData, *DstData;
__llvm_profile_header *Header = (__llvm_profile_header *)ProfileData; __llvm_profile_header *Header = (__llvm_profile_header *)ProfileData;
char *SrcCountersStart; char *SrcCountersStart;
char *SrcBitmaskStart;
const char *SrcNameStart; const char *SrcNameStart;
const char *SrcValueProfDataStart, *SrcValueProfData; const char *SrcValueProfDataStart, *SrcValueProfData;
uintptr_t CountersDelta = Header->CountersDelta; uintptr_t CountersDelta = Header->CountersDelta;
uintptr_t BitmaskDelta = Header->BitmaskDelta;
SrcDataStart = SrcDataStart =
(__llvm_profile_data *)(ProfileData + sizeof(__llvm_profile_header) + (__llvm_profile_data *)(ProfileData + sizeof(__llvm_profile_header) +
Header->BinaryIdsSize); Header->BinaryIdsSize);
SrcDataEnd = SrcDataStart + Header->DataSize; SrcDataEnd = SrcDataStart + Header->DataSize;
SrcCountersStart = (char *)SrcDataEnd; SrcCountersStart = (char *)SrcDataEnd;
SrcNameStart = SrcCountersStart + SrcBitmaskStart = SrcCountersStart +
Header->CountersSize * __llvm_profile_counter_entry_size(); Header->CountersSize * __llvm_profile_counter_entry_size();
SrcNameStart = SrcBitmaskStart + Header->NumBitmaskBytes;
SrcValueProfDataStart = SrcValueProfDataStart =
SrcNameStart + Header->NamesSize + SrcNameStart + Header->NamesSize +
__llvm_profile_get_num_padding_bytes(Header->NamesSize); __llvm_profile_get_num_padding_bytes(Header->NamesSize);
if (SrcNameStart < SrcCountersStart) if (SrcNameStart < SrcCountersStart || SrcNameStart < SrcBitmaskStart)
return 1; return 1;
for (SrcData = SrcDataStart, for (SrcData = SrcDataStart,
DstData = (__llvm_profile_data *)__llvm_profile_begin_data(), DstData = (__llvm_profile_data *)__llvm_profile_begin_data(),
SrcValueProfData = SrcValueProfDataStart; SrcValueProfData = SrcValueProfDataStart;
SrcData < SrcDataEnd; ++SrcData, ++DstData) { SrcData < SrcDataEnd; ++SrcData, ++DstData) {
// For the in-memory destination, CounterPtr is the distance from the start // For the in-memory destination, CounterPtr is the distance from the start
// address of the data to the start address of the counter. On WIN64, // address of the data to the start address of the counter. On WIN64,
// CounterPtr is a truncated 32-bit value due to COFF limitation. Sign // CounterPtr is a truncated 32-bit value due to COFF limitation. Sign
// extend CounterPtr to get the original value. // extend CounterPtr to get the original value.
char *DstCounters = char *DstCounters =
(char *)((uintptr_t)DstData + signextIfWin64(DstData->CounterPtr)); (char *)((uintptr_t)DstData + signextIfWin64(DstData->CounterPtr));
char *DstBitmask =
(char *)((uintptr_t)DstData + signextIfWin64(DstData->BitmaskPtr));
unsigned NVK = 0; unsigned NVK = 0;
// SrcData is a serialized representation of the memory image. We need to // SrcData is a serialized representation of the memory image. We need to
// compute the in-buffer counter offset from the in-memory address distance. // compute the in-buffer counter offset from the in-memory address distance.
// The initial CountersDelta is the in-memory address difference // The initial CountersDelta is the in-memory address difference
// start(__llvm_prf_cnts)-start(__llvm_prf_data), so SrcData->CounterPtr - // start(__llvm_prf_cnts)-start(__llvm_prf_data), so SrcData->CounterPtr -
// CountersDelta computes the offset into the in-buffer counter section. // CountersDelta computes the offset into the in-buffer counter section.
// //
Show All 13 Lines for (unsigned I = 0; I < NC; I++) {
if (__llvm_profile_get_version() & VARIANT_MASK_BYTE_COVERAGE) { if (__llvm_profile_get_version() & VARIANT_MASK_BYTE_COVERAGE) {
// A value of zero signifies the function is covered. // A value of zero signifies the function is covered.
DstCounters[I] &= SrcCounters[I]; DstCounters[I] &= SrcCounters[I];
} else { } else {
((uint64_t *)DstCounters)[I] += ((uint64_t *)SrcCounters)[I]; ((uint64_t *)DstCounters)[I] += ((uint64_t *)SrcCounters)[I];
} }
} }
char *SrcBitmask =
SrcBitmaskStart + ((uintptr_t)SrcData->BitmaskPtr - BitmaskDelta);
// BitmaskDelta also needs to be decreased as we advance to the next data
// record.
BitmaskDelta -= sizeof(*SrcData);
unsigned NB = SrcData->NumBitmaskBytes;
// NumBitmaskBytes may legitimately be 0. Just keep going.
if (NB != 0) {
if (SrcBitmask < SrcBitmaskStart || (SrcBitmask + NB) > SrcNameStart)
return 1;
for (unsigned I = 0; I < NB; I++)
DstBitmask[I] |= SrcBitmask[I];
}
/* Now merge value profile data. */ /* Now merge value profile data. */
if (!VPMergeHook) if (!VPMergeHook)
continue; continue;
for (unsigned I = 0; I <= IPVK_Last; I++) for (unsigned I = 0; I <= IPVK_Last; I++)
NVK += (SrcData->NumValueSites[I] != 0); NVK += (SrcData->NumValueSites[I] != 0);
if (!NVK) if (!NVK)
Show All 11 Lines

compiler-rt/lib/profile/InstrProfilingPlatformDarwin.c

Show All 25 Lines
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
extern char NamesEnd __asm("section$end$__DATA$" INSTR_PROF_NAME_SECT_NAME); extern char NamesEnd __asm("section$end$__DATA$" INSTR_PROF_NAME_SECT_NAME);
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
extern char extern char
CountersStart __asm("section$start$__DATA$" INSTR_PROF_CNTS_SECT_NAME); CountersStart __asm("section$start$__DATA$" INSTR_PROF_CNTS_SECT_NAME);
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
extern char CountersEnd __asm("section$end$__DATA$" INSTR_PROF_CNTS_SECT_NAME); extern char CountersEnd __asm("section$end$__DATA$" INSTR_PROF_CNTS_SECT_NAME);
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
extern char
BitmaskStart __asm("section$start$__DATA$" INSTR_PROF_BITS_SECT_NAME);
COMPILER_RT_VISIBILITY
extern char BitmaskEnd __asm("section$end$__DATA$" INSTR_PROF_BITS_SECT_NAME);
COMPILER_RT_VISIBILITY
extern uint32_t extern uint32_t
OrderFileStart __asm("section$start$__DATA$" INSTR_PROF_ORDERFILE_SECT_NAME); OrderFileStart __asm("section$start$__DATA$" INSTR_PROF_ORDERFILE_SECT_NAME);
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
extern ValueProfNode extern ValueProfNode
VNodesStart __asm("section$start$__DATA$" INSTR_PROF_VNODES_SECT_NAME); VNodesStart __asm("section$start$__DATA$" INSTR_PROF_VNODES_SECT_NAME);
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
extern ValueProfNode extern ValueProfNode
Show All 9 Lines
const char *__llvm_profile_begin_names(void) { return &NamesStart; } const char *__llvm_profile_begin_names(void) { return &NamesStart; }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
const char *__llvm_profile_end_names(void) { return &NamesEnd; } const char *__llvm_profile_end_names(void) { return &NamesEnd; }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
char *__llvm_profile_begin_counters(void) { return &CountersStart; } char *__llvm_profile_begin_counters(void) { return &CountersStart; }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
char *__llvm_profile_end_counters(void) { return &CountersEnd; } char *__llvm_profile_end_counters(void) { return &CountersEnd; }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
char *__llvm_profile_begin_bitmask(void) { return &BitmaskStart; }
COMPILER_RT_VISIBILITY
char *__llvm_profile_end_bitmask(void) { return &BitmaskEnd; }
COMPILER_RT_VISIBILITY
uint32_t *__llvm_profile_begin_orderfile(void) { return &OrderFileStart; } uint32_t *__llvm_profile_begin_orderfile(void) { return &OrderFileStart; }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
ValueProfNode *__llvm_profile_begin_vnodes(void) { ValueProfNode *__llvm_profile_begin_vnodes(void) {
return &VNodesStart; return &VNodesStart;
} }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
ValueProfNode *__llvm_profile_end_vnodes(void) { return &VNodesEnd; } ValueProfNode *__llvm_profile_end_vnodes(void) { return &VNodesEnd; }
Show All 9 Lines

compiler-rt/lib/profile/InstrProfilingPlatformLinux.c

Show All 29 Lines
#endif #endif
#define PROF_DATA_START INSTR_PROF_SECT_START(INSTR_PROF_DATA_COMMON) #define PROF_DATA_START INSTR_PROF_SECT_START(INSTR_PROF_DATA_COMMON)
#define PROF_DATA_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_DATA_COMMON) #define PROF_DATA_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_DATA_COMMON)
#define PROF_NAME_START INSTR_PROF_SECT_START(INSTR_PROF_NAME_COMMON) #define PROF_NAME_START INSTR_PROF_SECT_START(INSTR_PROF_NAME_COMMON)
#define PROF_NAME_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_NAME_COMMON) #define PROF_NAME_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_NAME_COMMON)
#define PROF_CNTS_START INSTR_PROF_SECT_START(INSTR_PROF_CNTS_COMMON) #define PROF_CNTS_START INSTR_PROF_SECT_START(INSTR_PROF_CNTS_COMMON)
#define PROF_CNTS_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_CNTS_COMMON) #define PROF_CNTS_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_CNTS_COMMON)
#define PROF_BITS_START INSTR_PROF_SECT_START(INSTR_PROF_BITS_COMMON)
#define PROF_BITS_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_BITS_COMMON)
#define PROF_ORDERFILE_START INSTR_PROF_SECT_START(INSTR_PROF_ORDERFILE_COMMON) #define PROF_ORDERFILE_START INSTR_PROF_SECT_START(INSTR_PROF_ORDERFILE_COMMON)
#define PROF_VNODES_START INSTR_PROF_SECT_START(INSTR_PROF_VNODES_COMMON) #define PROF_VNODES_START INSTR_PROF_SECT_START(INSTR_PROF_VNODES_COMMON)
#define PROF_VNODES_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_VNODES_COMMON) #define PROF_VNODES_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_VNODES_COMMON)
/* Declare section start and stop symbols for various sections /* Declare section start and stop symbols for various sections
* generated by compiler instrumentation. * generated by compiler instrumentation.
*/ */
extern __llvm_profile_data PROF_DATA_START COMPILER_RT_VISIBILITY extern __llvm_profile_data PROF_DATA_START COMPILER_RT_VISIBILITY
COMPILER_RT_WEAK; COMPILER_RT_WEAK;
extern __llvm_profile_data PROF_DATA_STOP COMPILER_RT_VISIBILITY extern __llvm_profile_data PROF_DATA_STOP COMPILER_RT_VISIBILITY
COMPILER_RT_WEAK; COMPILER_RT_WEAK;
extern char PROF_CNTS_START COMPILER_RT_VISIBILITY COMPILER_RT_WEAK; extern char PROF_CNTS_START COMPILER_RT_VISIBILITY COMPILER_RT_WEAK;
extern char PROF_CNTS_STOP COMPILER_RT_VISIBILITY COMPILER_RT_WEAK; extern char PROF_CNTS_STOP COMPILER_RT_VISIBILITY COMPILER_RT_WEAK;
extern char PROF_BITS_START COMPILER_RT_VISIBILITY COMPILER_RT_WEAK;
extern char PROF_BITS_STOP COMPILER_RT_VISIBILITY COMPILER_RT_WEAK;
extern uint32_t PROF_ORDERFILE_START COMPILER_RT_VISIBILITY COMPILER_RT_WEAK; extern uint32_t PROF_ORDERFILE_START COMPILER_RT_VISIBILITY COMPILER_RT_WEAK;
extern char PROF_NAME_START COMPILER_RT_VISIBILITY COMPILER_RT_WEAK; extern char PROF_NAME_START COMPILER_RT_VISIBILITY COMPILER_RT_WEAK;
extern char PROF_NAME_STOP COMPILER_RT_VISIBILITY COMPILER_RT_WEAK; extern char PROF_NAME_STOP COMPILER_RT_VISIBILITY COMPILER_RT_WEAK;
extern ValueProfNode PROF_VNODES_START COMPILER_RT_VISIBILITY COMPILER_RT_WEAK; extern ValueProfNode PROF_VNODES_START COMPILER_RT_VISIBILITY COMPILER_RT_WEAK;
extern ValueProfNode PROF_VNODES_STOP COMPILER_RT_VISIBILITY COMPILER_RT_WEAK; extern ValueProfNode PROF_VNODES_STOP COMPILER_RT_VISIBILITY COMPILER_RT_WEAK;
COMPILER_RT_VISIBILITY const __llvm_profile_data * COMPILER_RT_VISIBILITY const __llvm_profile_data *
__llvm_profile_begin_data(void) { __llvm_profile_begin_data(void) {
Show All 10 LinesCOMPILER_RT_VISIBILITY const char *__llvm_profile_end_names(void) {
return &PROF_NAME_STOP; return &PROF_NAME_STOP;
} }
COMPILER_RT_VISIBILITY char *__llvm_profile_begin_counters(void) { COMPILER_RT_VISIBILITY char *__llvm_profile_begin_counters(void) {
return &PROF_CNTS_START; return &PROF_CNTS_START;
} }
COMPILER_RT_VISIBILITY char *__llvm_profile_end_counters(void) { COMPILER_RT_VISIBILITY char *__llvm_profile_end_counters(void) {
return &PROF_CNTS_STOP; return &PROF_CNTS_STOP;
} }
COMPILER_RT_VISIBILITY char *__llvm_profile_begin_bitmask(void) {
return &PROF_BITS_START;
}
COMPILER_RT_VISIBILITY char *__llvm_profile_end_bitmask(void) {
return &PROF_BITS_STOP;
}
COMPILER_RT_VISIBILITY uint32_t *__llvm_profile_begin_orderfile(void) { COMPILER_RT_VISIBILITY uint32_t *__llvm_profile_begin_orderfile(void) {
return &PROF_ORDERFILE_START; return &PROF_ORDERFILE_START;
} }
COMPILER_RT_VISIBILITY ValueProfNode * COMPILER_RT_VISIBILITY ValueProfNode *
__llvm_profile_begin_vnodes(void) { __llvm_profile_begin_vnodes(void) {
return &PROF_VNODES_START; return &PROF_VNODES_START;
} }
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Lines
// alive through references in constructor functions that are always live in the // alive through references in constructor functions that are always live in the
// default linking model on AIX (-bcdtors:all). The __start_SECNAME and // default linking model on AIX (-bcdtors:all). The __start_SECNAME and
// __stop_SECNAME symbols are only resolved by the linker when the SECNAME // __stop_SECNAME symbols are only resolved by the linker when the SECNAME
// section exists. So for the scenario where the user objects have no such // section exists. So for the scenario where the user objects have no such
// section (i.e. when they are compiled with -fno-profile-generate), we always // section (i.e. when they are compiled with -fno-profile-generate), we always
// define these zero length variables in each of the above 4 sections. // define these zero length variables in each of the above 4 sections.
COMPILER_RT_VISIBILITY int dummy_cnts[0] COMPILER_RT_SECTION( COMPILER_RT_VISIBILITY int dummy_cnts[0] COMPILER_RT_SECTION(
COMPILER_RT_SEG INSTR_PROF_CNTS_SECT_NAME); COMPILER_RT_SEG INSTR_PROF_CNTS_SECT_NAME);
COMPILER_RT_VISIBILITY int dummy_bits[0] COMPILER_RT_SECTION(
COMPILER_RT_SEG INSTR_PROF_BITS_SECT_NAME);
COMPILER_RT_VISIBILITY int dummy_data[0] COMPILER_RT_SECTION( COMPILER_RT_VISIBILITY int dummy_data[0] COMPILER_RT_SECTION(
COMPILER_RT_SEG INSTR_PROF_DATA_SECT_NAME); COMPILER_RT_SEG INSTR_PROF_DATA_SECT_NAME);
COMPILER_RT_VISIBILITY const int dummy_name[0] COMPILER_RT_SECTION( COMPILER_RT_VISIBILITY const int dummy_name[0] COMPILER_RT_SECTION(
COMPILER_RT_SEG INSTR_PROF_NAME_SECT_NAME); COMPILER_RT_SEG INSTR_PROF_NAME_SECT_NAME);
COMPILER_RT_VISIBILITY int dummy_vnds[0] COMPILER_RT_SECTION( COMPILER_RT_VISIBILITY int dummy_vnds[0] COMPILER_RT_SECTION(
COMPILER_RT_SEG INSTR_PROF_VNODES_SECT_NAME); COMPILER_RT_SEG INSTR_PROF_VNODES_SECT_NAME);
// Create a fake reference to avoid GC'ing of the dummy variables by the linker. // Create a fake reference to avoid GC'ing of the dummy variables by the linker.
Show All 10 Lines

compiler-rt/lib/profile/InstrProfilingPlatformOther.c

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
const char *__llvm_profile_begin_names(void) { return NamesFirst; } const char *__llvm_profile_begin_names(void) { return NamesFirst; }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
const char *__llvm_profile_end_names(void) { return NamesLast; } const char *__llvm_profile_end_names(void) { return NamesLast; }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
char *__llvm_profile_begin_counters(void) { return CountersFirst; } char *__llvm_profile_begin_counters(void) { return CountersFirst; }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
char *__llvm_profile_end_counters(void) { return CountersLast; } char *__llvm_profile_end_counters(void) { return CountersLast; }
COMPILER_RT_VISIBILITY
char *__llvm_profile_begin_bitmask(void) { return BitmaskFirst; }
COMPILER_RT_VISIBILITY
char *__llvm_profile_end_bitmask(void) { return BitmaskLast; }
/* TODO: correctly set up OrderFileFirst. */ /* TODO: correctly set up OrderFileFirst. */
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
uint32_t *__llvm_profile_begin_orderfile(void) { return OrderFileFirst; } uint32_t *__llvm_profile_begin_orderfile(void) { return OrderFileFirst; }
COMPILER_RT_VISIBILITY COMPILER_RT_VISIBILITY
ValueProfNode *__llvm_profile_begin_vnodes(void) { ValueProfNode *__llvm_profile_begin_vnodes(void) {
return 0; return 0;
} }
Show All 11 Lines

compiler-rt/lib/profile/InstrProfilingPlatformWindows.c

/*===- InstrProfilingPlatformWindows.c - Profile data on Windows ----------===*\ /*===- InstrProfilingPlatformWindows.c - Profile data on Windows ----------===*\
|* |*
|* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|* See https://llvm.org/LICENSE.txt for license information. |* See https://llvm.org/LICENSE.txt for license information.
|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|* |*
\*===----------------------------------------------------------------------===*/ \*===----------------------------------------------------------------------===*/
#include "InstrProfiling.h" #include "InstrProfiling.h"
#include "InstrProfilingInternal.h" #include "InstrProfilingInternal.h"
#if defined(_WIN32) #if defined(_WIN32)
#if defined(_MSC_VER) #if defined(_MSC_VER)
/* Merge read-write sections into .data. */ /* Merge read-write sections into .data. */
#pragma comment(linker, "/MERGE:.lprfc=.data") #pragma comment(linker, "/MERGE:.lprfc=.data")
#pragma comment(linker, "/MERGE:.lprfb=.data")
#pragma comment(linker, "/MERGE:.lprfd=.data") #pragma comment(linker, "/MERGE:.lprfd=.data")
#pragma comment(linker, "/MERGE:.lprfv=.data") #pragma comment(linker, "/MERGE:.lprfv=.data")
#pragma comment(linker, "/MERGE:.lprfnd=.data") #pragma comment(linker, "/MERGE:.lprfnd=.data")
/* Do *NOT* merge .lprfn and .lcovmap into .rdata. llvm-cov must be able to find /* Do *NOT* merge .lprfn and .lcovmap into .rdata. llvm-cov must be able to find
* after the fact. * after the fact.
*/ */
/* Allocate read-only section bounds. */ /* Allocate read-only section bounds. */
#pragma section(".lprfn$A", read) #pragma section(".lprfn$A", read)
#pragma section(".lprfn$Z", read) #pragma section(".lprfn$Z", read)
/* Allocate read-write section bounds. */ /* Allocate read-write section bounds. */
#pragma section(".lprfd$A", read, write) #pragma section(".lprfd$A", read, write)
#pragma section(".lprfd$Z", read, write) #pragma section(".lprfd$Z", read, write)
#pragma section(".lprfc$A", read, write) #pragma section(".lprfc$A", read, write)
#pragma section(".lprfc$Z", read, write) #pragma section(".lprfc$Z", read, write)
#pragma section(".lprfb$A", read, write)
#pragma section(".lprfb$Z", read, write)
#pragma section(".lorderfile$A", read, write) #pragma section(".lorderfile$A", read, write)
#pragma section(".lprfnd$A", read, write) #pragma section(".lprfnd$A", read, write)
#pragma section(".lprfnd$Z", read, write) #pragma section(".lprfnd$Z", read, write)
#endif #endif
__llvm_profile_data COMPILER_RT_SECTION(".lprfd$A") DataStart = {0}; __llvm_profile_data COMPILER_RT_SECTION(".lprfd$A") DataStart = {0};
__llvm_profile_data COMPILER_RT_SECTION(".lprfd$Z") DataEnd = {0}; __llvm_profile_data COMPILER_RT_SECTION(".lprfd$Z") DataEnd = {0};
const char COMPILER_RT_SECTION(".lprfn$A") NamesStart = '\0'; const char COMPILER_RT_SECTION(".lprfn$A") NamesStart = '\0';
const char COMPILER_RT_SECTION(".lprfn$Z") NamesEnd = '\0'; const char COMPILER_RT_SECTION(".lprfn$Z") NamesEnd = '\0';
char COMPILER_RT_SECTION(".lprfc$A") CountersStart; char COMPILER_RT_SECTION(".lprfc$A") CountersStart;
char COMPILER_RT_SECTION(".lprfc$Z") CountersEnd; char COMPILER_RT_SECTION(".lprfc$Z") CountersEnd;
char COMPILER_RT_SECTION(".lprfb$A") BitmaskStart;
char COMPILER_RT_SECTION(".lprfb$Z") BitmaskEnd;
uint32_t COMPILER_RT_SECTION(".lorderfile$A") OrderFileStart; uint32_t COMPILER_RT_SECTION(".lorderfile$A") OrderFileStart;
ValueProfNode COMPILER_RT_SECTION(".lprfnd$A") VNodesStart; ValueProfNode COMPILER_RT_SECTION(".lprfnd$A") VNodesStart;
ValueProfNode COMPILER_RT_SECTION(".lprfnd$Z") VNodesEnd; ValueProfNode COMPILER_RT_SECTION(".lprfnd$Z") VNodesEnd;
const __llvm_profile_data *__llvm_profile_begin_data(void) { const __llvm_profile_data *__llvm_profile_begin_data(void) {
return &DataStart + 1; return &DataStart + 1;
} }
const __llvm_profile_data *__llvm_profile_end_data(void) { return &DataEnd; } const __llvm_profile_data *__llvm_profile_end_data(void) { return &DataEnd; }
const char *__llvm_profile_begin_names(void) { return &NamesStart + 1; } const char *__llvm_profile_begin_names(void) { return &NamesStart + 1; }
const char *__llvm_profile_end_names(void) { return &NamesEnd; } const char *__llvm_profile_end_names(void) { return &NamesEnd; }
char *__llvm_profile_begin_counters(void) { return &CountersStart + 1; } char *__llvm_profile_begin_counters(void) { return &CountersStart + 1; }
char *__llvm_profile_end_counters(void) { return &CountersEnd; } char *__llvm_profile_end_counters(void) { return &CountersEnd; }
char *__llvm_profile_begin_bitmask(void) { return &BitmaskStart + 1; }
char *__llvm_profile_end_bitmask(void) { return &BitmaskEnd; }
uint32_t *__llvm_profile_begin_orderfile(void) { return &OrderFileStart; } uint32_t *__llvm_profile_begin_orderfile(void) { return &OrderFileStart; }
ValueProfNode *__llvm_profile_begin_vnodes(void) { return &VNodesStart + 1; } ValueProfNode *__llvm_profile_begin_vnodes(void) { return &VNodesStart + 1; }
ValueProfNode *__llvm_profile_end_vnodes(void) { return &VNodesEnd; } ValueProfNode *__llvm_profile_end_vnodes(void) { return &VNodesEnd; }
ValueProfNode *CurrentVNode = &VNodesStart + 1; ValueProfNode *CurrentVNode = &VNodesStart + 1;
ValueProfNode *EndVNode = &VNodesEnd; ValueProfNode *EndVNode = &VNodesEnd;
COMPILER_RT_VISIBILITY int __llvm_write_binary_ids(ProfDataWriter *Writer) { COMPILER_RT_VISIBILITY int __llvm_write_binary_ids(ProfDataWriter *Writer) {
return 0; return 0;
} }
#endif #endif

compiler-rt/lib/profile/InstrProfilingWriter.c

Show First 20 Lines • Show All 240 Lines • ▼ Show 20 Lines
COMPILER_RT_VISIBILITY int lprofWriteData(ProfDataWriter *Writer, COMPILER_RT_VISIBILITY int lprofWriteData(ProfDataWriter *Writer,
VPDataReaderType *VPDataReader, VPDataReaderType *VPDataReader,
int SkipNameDataWrite) { int SkipNameDataWrite) {
/* Match logic in __llvm_profile_write_buffer(). */ /* Match logic in __llvm_profile_write_buffer(). */
const __llvm_profile_data *DataBegin = __llvm_profile_begin_data(); const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
const __llvm_profile_data *DataEnd = __llvm_profile_end_data(); const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
const char *CountersBegin = __llvm_profile_begin_counters(); const char *CountersBegin = __llvm_profile_begin_counters();
const char *CountersEnd = __llvm_profile_end_counters(); const char *CountersEnd = __llvm_profile_end_counters();
const char *BitmaskBegin = __llvm_profile_begin_bitmask();
const char *BitmaskEnd = __llvm_profile_end_bitmask();
const char *NamesBegin = __llvm_profile_begin_names(); const char *NamesBegin = __llvm_profile_begin_names();
const char *NamesEnd = __llvm_profile_end_names(); const char *NamesEnd = __llvm_profile_end_names();
return lprofWriteDataImpl(Writer, DataBegin, DataEnd, CountersBegin, return lprofWriteDataImpl(Writer, DataBegin, DataEnd, CountersBegin,
CountersEnd, VPDataReader, NamesBegin, NamesEnd, CountersEnd, BitmaskBegin, BitmaskEnd, VPDataReader,
SkipNameDataWrite); NamesBegin, NamesEnd, SkipNameDataWrite);
} }
COMPILER_RT_VISIBILITY int COMPILER_RT_VISIBILITY int
lprofWriteDataImpl(ProfDataWriter *Writer, const __llvm_profile_data *DataBegin, lprofWriteDataImpl(ProfDataWriter *Writer, const __llvm_profile_data *DataBegin,
const __llvm_profile_data *DataEnd, const __llvm_profile_data *DataEnd,
const char *CountersBegin, const char *CountersEnd, const char *CountersBegin, const char *CountersEnd,
const char *BitmaskBegin, const char *BitmaskEnd,
VPDataReaderType *VPDataReader, const char *NamesBegin, VPDataReaderType *VPDataReader, const char *NamesBegin,
const char *NamesEnd, int SkipNameDataWrite) { const char *NamesEnd, int SkipNameDataWrite) {
int DebugInfoCorrelate = int DebugInfoCorrelate =
(__llvm_profile_get_version() & VARIANT_MASK_DBG_CORRELATE) != 0ULL; (__llvm_profile_get_version() & VARIANT_MASK_DBG_CORRELATE) != 0ULL;
/* Calculate size of sections. */ /* Calculate size of sections. */
const uint64_t DataSectionSize = const uint64_t DataSectionSize =
DebugInfoCorrelate ? 0 : __llvm_profile_get_data_size(DataBegin, DataEnd); DebugInfoCorrelate ? 0 : __llvm_profile_get_data_size(DataBegin, DataEnd);
const uint64_t NumData = const uint64_t NumData =
DebugInfoCorrelate ? 0 : __llvm_profile_get_num_data(DataBegin, DataEnd); DebugInfoCorrelate ? 0 : __llvm_profile_get_num_data(DataBegin, DataEnd);
const uint64_t CountersSectionSize = const uint64_t CountersSectionSize =
__llvm_profile_get_counters_size(CountersBegin, CountersEnd); __llvm_profile_get_counters_size(CountersBegin, CountersEnd);
const uint64_t NumCounters = const uint64_t NumCounters =
__llvm_profile_get_num_counters(CountersBegin, CountersEnd); __llvm_profile_get_num_counters(CountersBegin, CountersEnd);
const uint64_t NumBitmaskBytes =
__llvm_profile_get_num_bitmask_bytes(BitmaskBegin, BitmaskEnd);
const uint64_t NamesSize = DebugInfoCorrelate ? 0 : NamesEnd - NamesBegin; const uint64_t NamesSize = DebugInfoCorrelate ? 0 : NamesEnd - NamesBegin;
/* Create the header. */ /* Create the header. */
__llvm_profile_header Header; __llvm_profile_header Header;
/* Determine how much padding is needed before/after the counters and after /* Determine how much padding is needed before/after the counters and after
* the names. */ * the names. */
uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters, uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters,
PaddingBytesAfterNames; PaddingBytesAfterNames, PaddingBytesAfterBitmaskBytes;
__llvm_profile_get_padding_sizes_for_counters( __llvm_profile_get_padding_sizes_for_counters(
DataSectionSize, CountersSectionSize, NamesSize, DataSectionSize, CountersSectionSize, NumBitmaskBytes, NamesSize,
&PaddingBytesBeforeCounters, &PaddingBytesAfterCounters, &PaddingBytesBeforeCounters, &PaddingBytesAfterCounters,
&PaddingBytesAfterNames); &PaddingBytesAfterBitmaskBytes, &PaddingBytesAfterNames);
{ {
// TODO: Unfortunately the header's fields are named DataSize and // TODO: Unfortunately the header's fields are named DataSize and
// CountersSize when they should be named NumData and NumCounters, // CountersSize when they should be named NumData and NumCounters,
// respectively. // respectively.
const uint64_t CountersSize = NumCounters; const uint64_t CountersSize = NumCounters;
const uint64_t DataSize = NumData; const uint64_t DataSize = NumData;
/* Initialize header structure. */ /* Initialize header structure. */
#define INSTR_PROF_RAW_HEADER(Type, Name, Init) Header.Name = Init; #define INSTR_PROF_RAW_HEADER(Type, Name, Init) Header.Name = Init;
#include "profile/InstrProfData.inc" #include "profile/InstrProfData.inc"
} }
/* On WIN64, label differences are truncated 32-bit values. Truncate /* On WIN64, label differences are truncated 32-bit values. Truncate
* CountersDelta to match. */ * CountersDelta to match. */
#ifdef _WIN64 #ifdef _WIN64
Header.CountersDelta = (uint32_t)Header.CountersDelta; Header.CountersDelta = (uint32_t)Header.CountersDelta;
Header.BitmaskDelta = (uint32_t)Header.BitmaskDelta;
#endif #endif
/* The data and names sections are omitted in lightweight mode. */ /* The data and names sections are omitted in lightweight mode. */
if (DebugInfoCorrelate) { if (DebugInfoCorrelate) {
Header.CountersDelta = 0; Header.CountersDelta = 0;
Header.NamesDelta = 0; Header.NamesDelta = 0;
} }
/* Write the profile header. */ /* Write the profile header. */
ProfDataIOVec IOVec[] = {{&Header, sizeof(__llvm_profile_header), 1, 0}}; ProfDataIOVec IOVec[] = {{&Header, sizeof(__llvm_profile_header), 1, 0}};
if (Writer->Write(Writer, IOVec, sizeof(IOVec) / sizeof(*IOVec))) if (Writer->Write(Writer, IOVec, sizeof(IOVec) / sizeof(*IOVec)))
return -1; return -1;
/* Write the binary id lengths and data. */ /* Write the binary id lengths and data. */
if (__llvm_write_binary_ids(Writer) == -1) if (__llvm_write_binary_ids(Writer) == -1)
return -1; return -1;
/* Write the profile data. */ /* Write the profile data. */
ProfDataIOVec IOVecData[] = { ProfDataIOVec IOVecData[] = {
{DebugInfoCorrelate ? NULL : DataBegin, sizeof(uint8_t), DataSectionSize, {DebugInfoCorrelate ? NULL : DataBegin, sizeof(uint8_t), DataSectionSize,
0}, 0},
{NULL, sizeof(uint8_t), PaddingBytesBeforeCounters, 1}, {NULL, sizeof(uint8_t), PaddingBytesBeforeCounters, 1},
{CountersBegin, sizeof(uint8_t), CountersSectionSize, 0}, {CountersBegin, sizeof(uint8_t), CountersSectionSize, 0},
{NULL, sizeof(uint8_t), PaddingBytesAfterCounters, 1}, {NULL, sizeof(uint8_t), PaddingBytesAfterCounters, 1},
{BitmaskBegin, sizeof(uint8_t), NumBitmaskBytes, 0},
{NULL, sizeof(uint8_t), PaddingBytesAfterBitmaskBytes, 1},
{(SkipNameDataWrite || DebugInfoCorrelate) ? NULL : NamesBegin, {(SkipNameDataWrite || DebugInfoCorrelate) ? NULL : NamesBegin,
sizeof(uint8_t), NamesSize, 0}, sizeof(uint8_t), NamesSize, 0},
{NULL, sizeof(uint8_t), PaddingBytesAfterNames, 1}}; {NULL, sizeof(uint8_t), PaddingBytesAfterNames, 1}};
if (Writer->Write(Writer, IOVecData, sizeof(IOVecData) / sizeof(*IOVecData))) if (Writer->Write(Writer, IOVecData, sizeof(IOVecData) / sizeof(*IOVecData)))
return -1; return -1;
/* Value profiling is not yet supported in continuous mode. */ /* Value profiling is not yet supported in continuous mode. */
if (__llvm_profile_is_continuous_mode_enabled()) if (__llvm_profile_is_continuous_mode_enabled())
return 0; return 0;
return writeValueProfData(Writer, VPDataReader, DataBegin, DataEnd); return writeValueProfData(Writer, VPDataReader, DataBegin, DataEnd);
} }

compiler-rt/test/profile/ContinuousSyncMode/image-with-mcdc.c

  • This file was added.
// REQUIRES: darwin
// RUN: %clang_profgen -fcoverage-mapping -fmcdc -O3 -o %t.exe %s
// RUN: env LLVM_PROFILE_FILE="%c%t.profraw" %run %t.exe 3 3
// RUN: llvm-profdata show --text --all-functions %t.profraw | FileCheck %s
// CHECK: Num Bitmask Bytes:
// CHECK-NEXT: $1
// CHECK-NEXT: Bitmask Byte Values:
// CHECK-NEXT: 8
#include <stdlib.h>
#include <stdio.h>
extern int __llvm_profile_is_continuous_mode_enabled(void);
int main(int argc, char *const argv[]) {
if (!__llvm_profile_is_continuous_mode_enabled())
return 1;
if (argc < 3)
return 1;
if ((atoi(argv[1]) > 2) && (atoi(argv[2]) > 2)) {
printf("Decision Satisfied");
}
return 0;
}

compiler-rt/test/profile/instrprof-write-buffer-internal.c

Show All 19 Lines
#include <stdlib.h> #include <stdlib.h>
const void *__llvm_profile_begin_data(void); const void *__llvm_profile_begin_data(void);
const void *__llvm_profile_end_data(void); const void *__llvm_profile_end_data(void);
const char *__llvm_profile_begin_names(void); const char *__llvm_profile_begin_names(void);
const char *__llvm_profile_end_names(void); const char *__llvm_profile_end_names(void);
char *__llvm_profile_begin_counters(void); char *__llvm_profile_begin_counters(void);
char *__llvm_profile_end_counters(void); char *__llvm_profile_end_counters(void);
char *__llvm_profile_begin_bitmask(void);
char *__llvm_profile_end_bitmask(void);
uint64_t __llvm_profile_get_size_for_buffer_internal( uint64_t __llvm_profile_get_size_for_buffer_internal(
const void *DataBegin, const void *DataEnd, const char *CountersBegin, const void *DataBegin, const void *DataEnd, const char *CountersBegin,
const char *CountersEnd, const char *NamesBegin, const char *NamesEnd); const char *CountersEnd, const char *BitmaskBegin, const char *BitmaskEnd,
const char *NamesBegin, const char *NamesEnd);
int __llvm_profile_write_buffer_internal(char *Buffer, const void *DataBegin, int __llvm_profile_write_buffer_internal(char *Buffer, const void *DataBegin,
const void *DataEnd, const void *DataEnd,
const char *CountersBegin, const char *CountersBegin,
const char *CountersEnd, const char *CountersEnd,
const char *BitmaskBegin,
const char *BitmaskEnd,
const char *NamesBegin, const char *NamesBegin,
const char *NamesEnd); const char *NamesEnd);
void __llvm_profile_set_dumped(void); void __llvm_profile_set_dumped(void);
int main(int argc, const char *argv[]) { int main(int argc, const char *argv[]) {
uint64_t bufsize = __llvm_profile_get_size_for_buffer_internal( uint64_t bufsize = __llvm_profile_get_size_for_buffer_internal(
__llvm_profile_begin_data(), __llvm_profile_end_data(), __llvm_profile_begin_data(), __llvm_profile_end_data(),
__llvm_profile_begin_counters(), __llvm_profile_end_counters(), __llvm_profile_begin_counters(), __llvm_profile_end_counters(),
__llvm_profile_begin_bitmask(), __llvm_profile_end_bitmask(),
__llvm_profile_begin_names(), __llvm_profile_end_names()); __llvm_profile_begin_names(), __llvm_profile_end_names());
char *buf = malloc(bufsize); char *buf = malloc(bufsize);
int ret = __llvm_profile_write_buffer_internal(buf, int ret = __llvm_profile_write_buffer_internal(buf,
__llvm_profile_begin_data(), __llvm_profile_end_data(), __llvm_profile_begin_data(), __llvm_profile_end_data(),
__llvm_profile_begin_counters(), __llvm_profile_end_counters(), __llvm_profile_begin_counters(), __llvm_profile_end_counters(),
__llvm_profile_begin_bitmask(), __llvm_profile_end_bitmask(),
__llvm_profile_begin_names(), __llvm_profile_end_names()); __llvm_profile_begin_names(), __llvm_profile_end_names());
if (ret != 0) { if (ret != 0) {
fprintf(stderr, "failed to write buffer"); fprintf(stderr, "failed to write buffer");
return ret; return ret;
} }
FILE *f = fopen(argv[1], "w"); FILE *f = fopen(argv[1], "w");
fwrite(buf, bufsize, 1, f); fwrite(buf, bufsize, 1, f);
fclose(f); fclose(f);
free(buf); free(buf);
__llvm_profile_set_dumped(); __llvm_profile_set_dumped();
return 0; return 0;
} }

llvm/include/llvm/IR/IntrinsicInst.h

Show First 20 Lines • Show All 1,245 Lines • ▼ Show 20 Linespublic:
// The hash of the CFG for the instrumented function. // The hash of the CFG for the instrumented function.
ConstantInt *getHash() const { ConstantInt *getHash() const {
return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1))); return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
} }
// The number of counters for the instrumented function. // The number of counters for the instrumented function.
ConstantInt *getNumCounters() const; ConstantInt *getNumCounters() const;
// The index of the counter that this instruction acts on. // The index of the counter that this instruction acts on.
ConstantInt *getIndex() const; ConstantInt *getIndex() const;
// The number of bytes used for MCDC bitmasks for the instrumented function.
ConstantInt *getNumBitmaskBytes() const;
}; };
/// This represents the llvm.instrprof.cover intrinsic. /// This represents the llvm.instrprof.cover intrinsic.
class InstrProfCoverInst : public InstrProfInstBase { class InstrProfCoverInst : public InstrProfInstBase {
public: public:
static bool classof(const IntrinsicInst *I) { static bool classof(const IntrinsicInst *I) {
return I->getIntrinsicID() == Intrinsic::instrprof_cover; return I->getIntrinsicID() == Intrinsic::instrprof_cover;
} }
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linespublic:
} }
// Returns the value site index. // Returns the value site index.
ConstantInt *getIndex() const { ConstantInt *getIndex() const {
return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4))); return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4)));
} }
}; };
/// This represents the llvm.instrprof.mcdc.parameters intrinsic.
class InstrProfMCDCParameters : public InstrProfInstBase {
public:
static bool classof(const IntrinsicInst *I) {
return I->getIntrinsicID() == Intrinsic::instrprof_mcdc_parameters;
}
static bool classof(const Value *V) {
return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
}
};
/// This represents the llvm.instrprof.mcdc.bitmask.update intrinsic.
class InstrProfMCDCBitmaskUpdate : public InstrProfInstBase {
public:
static bool classof(const IntrinsicInst *I) {
return I->getIntrinsicID() == Intrinsic::instrprof_mcdc_bitmask_update;
}
static bool classof(const Value *V) {
return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
}
// The index of the bitmask that this instruction acts on.
ConstantInt *getBitmaskIndex() const {
return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
}
Value *getTempAddr() const {
return cast<Value>(const_cast<Value *>(getArgOperand(4)));
}
};
/// This represents the llvm.instrprof.mcdc.temp.update intrinsic.
class InstrProfMCDCTempUpdate : public InstrProfInstBase {
public:
static bool classof(const IntrinsicInst *I) {
return I->getIntrinsicID() == Intrinsic::instrprof_mcdc_temp_update;
}
static bool classof(const Value *V) {
return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
}
ConstantInt *getCondID() const {
return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
}
Value *getTempAddr() const {
return cast<Value>(const_cast<Value *>(getArgOperand(3)));
}
Value *getCondBool() const {
return cast<Value>(const_cast<Value *>(getArgOperand(4)));
}
};
class PseudoProbeInst : public IntrinsicInst { class PseudoProbeInst : public IntrinsicInst {
public: public:
static bool classof(const IntrinsicInst *I) { static bool classof(const IntrinsicInst *I) {
return I->getIntrinsicID() == Intrinsic::pseudoprobe; return I->getIntrinsicID() == Intrinsic::pseudoprobe;
} }
static bool classof(const Value *V) { static bool classof(const Value *V) {
return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V)); return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

llvm/include/llvm/IR/Intrinsics.td

Show First 20 Lines • Show All 609 Lines • ▼ Show 20 Lines
// A call to profile runtime for value profiling of target expressions // A call to profile runtime for value profiling of target expressions
// through instrumentation based profiling. // through instrumentation based profiling.
def int_instrprof_value_profile : Intrinsic<[], def int_instrprof_value_profile : Intrinsic<[],
[llvm_ptr_ty, llvm_i64_ty, [llvm_ptr_ty, llvm_i64_ty,
llvm_i64_ty, llvm_i32_ty, llvm_i64_ty, llvm_i32_ty,
llvm_i32_ty]>; llvm_i32_ty]>;
// A parameter configuration for instrumentation based MCDC profiling.
def int_instrprof_mcdc_parameters : Intrinsic<[],
[llvm_ptr_ty, llvm_i64_ty,
llvm_i32_ty]>;
// A bitmask update for instrumentation based MCDC profiling.
def int_instrprof_mcdc_bitmask_update : Intrinsic<[],
[llvm_ptr_ty, llvm_i64_ty,
llvm_i32_ty, llvm_i32_ty, llvm_ptr_ty]>;
// A temp value update for instrumentation based MCDC profiling.
def int_instrprof_mcdc_temp_update : Intrinsic<[],
[llvm_ptr_ty, llvm_i64_ty,
llvm_i32_ty, llvm_ptr_ty, llvm_i1_ty]>;
def int_call_preallocated_setup : DefaultAttrsIntrinsic<[llvm_token_ty], [llvm_i32_ty]>; def int_call_preallocated_setup : DefaultAttrsIntrinsic<[llvm_token_ty], [llvm_i32_ty]>;
def int_call_preallocated_arg : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_token_ty, llvm_i32_ty]>; def int_call_preallocated_arg : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_token_ty, llvm_i32_ty]>;
def int_call_preallocated_teardown : DefaultAttrsIntrinsic<[], [llvm_token_ty]>; def int_call_preallocated_teardown : DefaultAttrsIntrinsic<[], [llvm_token_ty]>;
//===------------------- Standard C Library Intrinsics --------------------===// //===------------------- Standard C Library Intrinsics --------------------===//
// //
def int_memcpy : Intrinsic<[], def int_memcpy : Intrinsic<[],
▲ Show 20 Lines • Show All 1,513 Lines • Show Last 20 Lines

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

Show All 9 Lines
// llvm-cov to show code coverage statistics for a file. // llvm-cov to show code coverage statistics for a file.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPING_H #ifndef LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPING_H
#define LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPING_H #define LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPING_H
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/BitVector.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseSet.h" #include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/Hashing.h" #include "llvm/ADT/Hashing.h"
#include "llvm/ADT/None.h" #include "llvm/ADT/None.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/ADT/iterator.h" #include "llvm/ADT/iterator.h"
#include "llvm/ADT/iterator_range.h" #include "llvm/ADT/iterator_range.h"
#include "llvm/ProfileData/InstrProf.h" #include "llvm/ProfileData/InstrProf.h"
#include "llvm/Support/Alignment.h" #include "llvm/Support/Alignment.h"
#include "llvm/Support/Compiler.h" #include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/Endian.h" #include "llvm/Support/Endian.h"
#include "llvm/Support/Error.h" #include "llvm/Support/Error.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <cassert> #include <cassert>
#include <cstdint> #include <cstdint>
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <sstream>
#include <string> #include <string>
#include <system_error> #include <system_error>
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <vector> #include <vector>
namespace llvm { namespace llvm {
▲ Show 20 Lines • Show All 177 Lines • ▼ Show 20 Lines enum RegionKind {
/// A GapRegion is like a CodeRegion, but its count is only set as the /// A GapRegion is like a CodeRegion, but its count is only set as the
/// line execution count when its the only region in the line. /// line execution count when its the only region in the line.
GapRegion, GapRegion,
/// A BranchRegion represents leaf-level boolean expressions and is /// A BranchRegion represents leaf-level boolean expressions and is
/// associated with two counters, each representing the number of times the /// associated with two counters, each representing the number of times the
/// expression evaluates to true or false. /// expression evaluates to true or false.
BranchRegion BranchRegion,
/// A DecisionRegion represents a top-level boolean expression and is
/// associated with a variable length bitmask counter and condition number.
MCDCDecisionRegion,
/// A Branch Region can be extended to include IDs to facilitate MC/DC.
MCDCBranchRegion
}; };
/// Primary Counter that is also used for Branch Regions (TrueCount). /// Primary Counter that is also used for Branch Regions (TrueCount).
Counter Count; Counter Count;
/// Secondary Counter used for Branch Regions (FalseCount). /// Secondary Counter used for Branch Regions (FalseCount).
Counter FalseCount; Counter FalseCount;
/// Byte Index of Bitmask Coverage Object for a Decision Region (MC/DC only).
unsigned Mask;
/// Number of Conditions used for a Decision Region (MC/DC only).
unsigned NumConditions;
/// IDs used to represent a branch region and other branch regions evaluated
/// based on True and False branches (MC/DC only).
unsigned ID, TrueID, FalseID;
unsigned FileID, ExpandedFileID; unsigned FileID, ExpandedFileID;
unsigned LineStart, ColumnStart, LineEnd, ColumnEnd; unsigned LineStart, ColumnStart, LineEnd, ColumnEnd;
RegionKind Kind; RegionKind Kind;
CounterMappingRegion(Counter Count, unsigned FileID, unsigned ExpandedFileID, CounterMappingRegion(Counter Count, unsigned FileID, unsigned ExpandedFileID,
unsigned LineStart, unsigned ColumnStart, unsigned LineStart, unsigned ColumnStart,
unsigned LineEnd, unsigned ColumnEnd, RegionKind Kind) unsigned LineEnd, unsigned ColumnEnd, RegionKind Kind)
: Count(Count), FileID(FileID), ExpandedFileID(ExpandedFileID), : Count(Count), FileID(FileID), ExpandedFileID(ExpandedFileID),
LineStart(LineStart), ColumnStart(ColumnStart), LineEnd(LineEnd), LineStart(LineStart), ColumnStart(ColumnStart), LineEnd(LineEnd),
ColumnEnd(ColumnEnd), Kind(Kind) {} ColumnEnd(ColumnEnd), Kind(Kind) {}
CounterMappingRegion(Counter Count, Counter FalseCount, unsigned FileID, CounterMappingRegion(Counter Count, Counter FalseCount, unsigned Mask,
unsigned NumConditions, unsigned ID, unsigned TrueID,
unsigned FalseID, unsigned FileID,
unsigned ExpandedFileID, unsigned LineStart,
unsigned ColumnStart, unsigned LineEnd,
unsigned ColumnEnd, RegionKind Kind)
: Count(Count), FalseCount(FalseCount), Mask(Mask),
NumConditions(NumConditions), ID(ID), TrueID(TrueID), FalseID(FalseID),
FileID(FileID), ExpandedFileID(ExpandedFileID), LineStart(LineStart),
ColumnStart(ColumnStart), LineEnd(LineEnd), ColumnEnd(ColumnEnd),
Kind(Kind) {}
CounterMappingRegion(unsigned Mask, unsigned NumConditions, unsigned FileID,
unsigned ExpandedFileID, unsigned LineStart, unsigned ExpandedFileID, unsigned LineStart,
unsigned ColumnStart, unsigned LineEnd, unsigned ColumnStart, unsigned LineEnd,
unsigned ColumnEnd, RegionKind Kind) unsigned ColumnEnd, RegionKind Kind)
: Count(Count), FalseCount(FalseCount), FileID(FileID), : Mask(Mask), NumConditions(NumConditions), FileID(FileID),
ExpandedFileID(ExpandedFileID), LineStart(LineStart), ExpandedFileID(ExpandedFileID), LineStart(LineStart),
ColumnStart(ColumnStart), LineEnd(LineEnd), ColumnEnd(ColumnEnd), ColumnStart(ColumnStart), LineEnd(LineEnd), ColumnEnd(ColumnEnd),
Kind(Kind) {} Kind(Kind) {}
static CounterMappingRegion static CounterMappingRegion
makeRegion(Counter Count, unsigned FileID, unsigned LineStart, makeRegion(Counter Count, unsigned FileID, unsigned LineStart,
unsigned ColumnStart, unsigned LineEnd, unsigned ColumnEnd) { unsigned ColumnStart, unsigned LineEnd, unsigned ColumnEnd) {
return CounterMappingRegion(Count, FileID, 0, LineStart, ColumnStart, return CounterMappingRegion(Count, FileID, 0, LineStart, ColumnStart,
Show All 18 Linesstruct CounterMappingRegion {
static CounterMappingRegion static CounterMappingRegion
makeGapRegion(Counter Count, unsigned FileID, unsigned LineStart, makeGapRegion(Counter Count, unsigned FileID, unsigned LineStart,
unsigned ColumnStart, unsigned LineEnd, unsigned ColumnEnd) { unsigned ColumnStart, unsigned LineEnd, unsigned ColumnEnd) {
return CounterMappingRegion(Count, FileID, 0, LineStart, ColumnStart, return CounterMappingRegion(Count, FileID, 0, LineStart, ColumnStart,
LineEnd, (1U << 31) | ColumnEnd, GapRegion); LineEnd, (1U << 31) | ColumnEnd, GapRegion);
} }
static CounterMappingRegion static CounterMappingRegion
makeBranchRegion(Counter Count, Counter FalseCount, unsigned FileID, makeBranchRegion(Counter Count, Counter FalseCount, unsigned ID,
unsigned TrueID, unsigned FalseID, unsigned FileID,
unsigned LineStart, unsigned ColumnStart, unsigned LineEnd, unsigned LineStart, unsigned ColumnStart, unsigned LineEnd,
unsigned ColumnEnd) { unsigned ColumnEnd) {
return CounterMappingRegion(Count, FalseCount, FileID, 0, LineStart, return CounterMappingRegion(Count, FalseCount, 0, 0, ID, TrueID, FalseID,
ColumnStart, LineEnd, ColumnEnd, BranchRegion); FileID, 0, LineStart, ColumnStart, LineEnd,
ColumnEnd,
ID == 0 ? BranchRegion : MCDCBranchRegion);
}
static CounterMappingRegion
makeDecisionRegion(unsigned Mask, unsigned NumConditions, unsigned FileID,
unsigned LineStart, unsigned ColumnStart, unsigned LineEnd,
unsigned ColumnEnd) {
return CounterMappingRegion(Mask, NumConditions, FileID, 0, LineStart,
ColumnStart, LineEnd, ColumnEnd,
MCDCDecisionRegion);
} }
inline LineColPair startLoc() const { inline LineColPair startLoc() const {
return LineColPair(LineStart, ColumnStart); return LineColPair(LineStart, ColumnStart);
} }
inline LineColPair endLoc() const { return LineColPair(LineEnd, ColumnEnd); } inline LineColPair endLoc() const { return LineColPair(LineEnd, ColumnEnd); }
}; };
Show All 9 Lines CountedRegion(const CounterMappingRegion &R, uint64_t ExecutionCount)
FalseExecutionCount(0), Folded(false) {} FalseExecutionCount(0), Folded(false) {}
CountedRegion(const CounterMappingRegion &R, uint64_t ExecutionCount, CountedRegion(const CounterMappingRegion &R, uint64_t ExecutionCount,
uint64_t FalseExecutionCount) uint64_t FalseExecutionCount)
: CounterMappingRegion(R), ExecutionCount(ExecutionCount), : CounterMappingRegion(R), ExecutionCount(ExecutionCount),
FalseExecutionCount(FalseExecutionCount), Folded(false) {} FalseExecutionCount(FalseExecutionCount), Folded(false) {}
}; };
/// MCDC Record grouping all information together.
struct MCDCRecord {
typedef enum { MCDC_DontCare = -1, MCDC_False = 0, MCDC_True = 1 } CondState;
using TestVector = std::vector<CondState>;
using TestVectors = std::vector<TestVector>;
using BoolVector = std::vector<bool>;
using TVRowPair = std::pair<unsigned, unsigned>;
using TVPairMap = llvm::DenseMap<unsigned, TVRowPair>;
using CondIDMap = llvm::DenseMap<unsigned, unsigned>;
using LineColPairMap = llvm::DenseMap<unsigned, LineColPair>;
private:
CounterMappingRegion Region;
TestVectors TV;
TVPairMap IndepPairs;
BoolVector Folded;
CondIDMap PosToID;
LineColPairMap CondLoc;
public:
MCDCRecord(CounterMappingRegion Region, TestVectors TV, TVPairMap IndepPairs,
BoolVector Folded, CondIDMap PosToID, LineColPairMap CondLoc)
: Region(Region), TV(TV), IndepPairs(IndepPairs), Folded(Folded),
PosToID(PosToID), CondLoc(CondLoc){};
CounterMappingRegion getDecisionRegion() const { return Region; }
unsigned getNumConditions() const { return Region.NumConditions; }
unsigned getNumTestVectors() const { return TV.size(); }
bool isCondFolded(unsigned Condition) const { return Folded[Condition]; }
CondState getTVCondition(unsigned TestVector, unsigned Condition) {
// Accessing conditions in the TestVectors requires a translation from a
// ordinal position to actual condition ID. This is done via PosToID[].
return TV[TestVector][PosToID[Condition]];
}
CondState getTVResult(unsigned TestVector) {
// The last value for a Test Vector, after its constituent conditions, is
// always the Result. See MCDCRecordProcessor::RecordTestVector().
return TV[TestVector][getNumConditions()];
}
bool isCondIndepPairCovered(unsigned Condition) const {
// Accessing conditions in the TestVector Row Pairs requires a translation
// from a ordinal position to actual condition ID. This is done via
// PosToID[].
auto it = PosToID.find(Condition);
if (it != PosToID.end())
return (IndepPairs.find(it->second) != IndepPairs.end());
llvm_unreachable("Condition ID without an Ordinal mapping");
}
TVRowPair getCondIndepPair(unsigned Condition) {
// Accessing conditions in the TestVector Row Pairs requires a translation
// from a ordinal position to actual condition ID. This is done via
// PosToID[].
assert(isCondIndepPairCovered(Condition));
return IndepPairs[PosToID[Condition]];
}
float getPercentCovered() const {
unsigned folded = 0;
unsigned covered = 0;
for (unsigned c = 0; c < getNumConditions(); c++) {
if (isCondFolded(c))
folded++;
else if (isCondIndepPairCovered(c))
covered++;
}
return ((double)(covered) / (double)(getNumConditions() - folded)) * 100.0;
}
std::string getConditionHdrStr(unsigned Condition) {
std::ostringstream ss;
ss << "Condition C" << Condition + 1 << " --> (";
ss << CondLoc[Condition].first << ":" << CondLoc[Condition].second;
ss << ")\n";
return ss.str();
}
std::string getTestVectorHdrStr() {
std::ostringstream ss;
if (getNumTestVectors() == 0) {
ss << "None.\n";
return ss.str();
}
for (unsigned i = 0; i < getNumConditions(); i++) {
ss << "C" << i + 1;
if (i != getNumConditions() - 1)
ss << ", ";
}
ss << " Result\n";
return ss.str();
}
std::string getTestVectorStr(unsigned TestVector) {
assert(TestVector < getNumTestVectors());
std::ostringstream ss;
// Print Individual Conditions
ss << " " << TestVector + 1 << " { ";
for (unsigned Condition = 0; Condition < getNumConditions(); Condition++) {
if (isCondFolded(Condition))
ss << "C";
else {
switch (getTVCondition(TestVector, Condition)) {
case MCDCRecord::MCDC_DontCare:
ss << "-";
break;
case MCDCRecord::MCDC_True:
ss << "T";
break;
case MCDCRecord::MCDC_False:
ss << "F";
break;
}
}
if (Condition != getNumConditions() - 1)
ss << ", ";
}
// Print Result
ss << " = ";
if (getTVResult(TestVector) == MCDC_True)
ss << "T";
else
ss << "F";
ss << " }\n";
return ss.str();
}
std::string getCondCoverageStr(unsigned Condition) {
assert(Condition < getNumConditions());
std::ostringstream ss;
ss << " C" << Condition + 1 << "-Pair: ";
if (isCondFolded(Condition)) {
ss << "constant folded\n";
} else if (isCondIndepPairCovered(Condition)) {
TVRowPair rows = getCondIndepPair(Condition);
ss << "covered: (" << rows.first << ",";
ss << rows.second << ")\n";
} else
ss << "not covered\n";
return ss.str();
}
};
/// A Counter mapping context is used to connect the counters, expressions /// A Counter mapping context is used to connect the counters, expressions
/// and the obtained counter values. /// and the obtained counter values.
class CounterMappingContext { class CounterMappingContext {
ArrayRef<CounterExpression> Expressions; ArrayRef<CounterExpression> Expressions;
ArrayRef<uint64_t> CounterValues; ArrayRef<uint64_t> CounterValues;
ArrayRef<uint8_t> BitmaskBytes;
public: public:
CounterMappingContext(ArrayRef<CounterExpression> Expressions, CounterMappingContext(ArrayRef<CounterExpression> Expressions,
ArrayRef<uint64_t> CounterValues = None) ArrayRef<uint64_t> CounterValues = None)
: Expressions(Expressions), CounterValues(CounterValues) {} : Expressions(Expressions), CounterValues(CounterValues) {}
void setCounts(ArrayRef<uint64_t> Counts) { CounterValues = Counts; } void setCounts(ArrayRef<uint64_t> Counts) { CounterValues = Counts; }
void setBitmaskBytes(ArrayRef<uint8_t> Bytes) { BitmaskBytes = Bytes; }
void dump(const Counter &C, raw_ostream &OS) const; void dump(const Counter &C, raw_ostream &OS) const;
void dump(const Counter &C) const { dump(C, dbgs()); } void dump(const Counter &C) const { dump(C, dbgs()); }
/// Return the number of times that a region of code associated with this /// Return the number of times that a region of code associated with this
/// counter was executed. /// counter was executed.
Expected<int64_t> evaluate(const Counter &C) const; Expected<int64_t> evaluate(const Counter &C) const;
/// Return the number of times that a region of code associated with this
/// counter was executed.
Expected<BitVector> evaluateBitmask(unsigned Bitmask, unsigned NumCond) const;
/// Return an MCDC record that indicates executed test vectors and condition
/// pairs.
Expected<MCDCRecord> evaluateMCDCRegion(CounterMappingRegion Region,
BitVector Bitmask, ArrayRef<CounterMappingRegion> Branches);
unsigned getMaxCounterID(const Counter &C) const; unsigned getMaxCounterID(const Counter &C) const;
}; };
/// Code coverage information for a single function. /// Code coverage information for a single function.
struct FunctionRecord { struct FunctionRecord {
/// Raw function name. /// Raw function name.
std::string Name; std::string Name;
/// Mapping from FileID (i.e. vector index) to filename. Used to support /// Mapping from FileID (i.e. vector index) to filename. Used to support
/// macro expansions within a function in which the macro and function are /// macro expansions within a function in which the macro and function are
/// defined in separate files. /// defined in separate files.
/// ///
/// TODO: Uniquing filenames across all function records may be a performance /// TODO: Uniquing filenames across all function records may be a performance
/// optimization. /// optimization.
std::vector<std::string> Filenames; std::vector<std::string> Filenames;
/// Regions in the function along with their counts. /// Regions in the function along with their counts.
std::vector<CountedRegion> CountedRegions; std::vector<CountedRegion> CountedRegions;
/// Branch Regions in the function along with their counts. /// Branch Regions in the function along with their counts.
std::vector<CountedRegion> CountedBranchRegions; std::vector<CountedRegion> CountedBranchRegions;
/// MCDC Records record a DecisionRegion and associated BranchRegions.
std::vector<MCDCRecord> MCDCRecords;
/// The number of times this function was executed. /// The number of times this function was executed.
uint64_t ExecutionCount = 0; uint64_t ExecutionCount = 0;
FunctionRecord(StringRef Name, ArrayRef<StringRef> Filenames) FunctionRecord(StringRef Name, ArrayRef<StringRef> Filenames)
: Name(Name), Filenames(Filenames.begin(), Filenames.end()) {} : Name(Name), Filenames(Filenames.begin(), Filenames.end()) {}
FunctionRecord(FunctionRecord &&FR) = default; FunctionRecord(FunctionRecord &&FR) = default;
FunctionRecord &operator=(FunctionRecord &&) = default; FunctionRecord &operator=(FunctionRecord &&) = default;
void pushMCDCRecord(MCDCRecord Record) { MCDCRecords.push_back(Record); }
void pushRegion(CounterMappingRegion Region, uint64_t Count, void pushRegion(CounterMappingRegion Region, uint64_t Count,
uint64_t FalseCount) { uint64_t FalseCount) {
if (Region.Kind == CounterMappingRegion::BranchRegion) { if (Region.Kind == CounterMappingRegion::BranchRegion ||
Region.Kind == CounterMappingRegion::MCDCBranchRegion) {
CountedBranchRegions.emplace_back(Region, Count, FalseCount); CountedBranchRegions.emplace_back(Region, Count, FalseCount);
// If both counters are hard-coded to zero, then this region represents a // If both counters are hard-coded to zero, then this region represents a
// constant-folded branch. // constant-folded branch.
if (Region.Count.isZero() && Region.FalseCount.isZero()) if (Region.Count.isZero() && Region.FalseCount.isZero())
CountedBranchRegions.back().Folded = true; CountedBranchRegions.back().Folded = true;
return; return;
} }
if (CountedRegions.empty()) if (CountedRegions.empty())
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Lines
/// list of expansions that can be further processed. /// list of expansions that can be further processed.
class CoverageData { class CoverageData {
friend class CoverageMapping; friend class CoverageMapping;
std::string Filename; std::string Filename;
std::vector<CoverageSegment> Segments; std::vector<CoverageSegment> Segments;
std::vector<ExpansionRecord> Expansions; std::vector<ExpansionRecord> Expansions;
std::vector<CountedRegion> BranchRegions; std::vector<CountedRegion> BranchRegions;
std::vector<MCDCRecord> MCDCRecords;
public: public:
CoverageData() = default; CoverageData() = default;
CoverageData(StringRef Filename) : Filename(Filename) {} CoverageData(StringRef Filename) : Filename(Filename) {}
/// Get the name of the file this data covers. /// Get the name of the file this data covers.
StringRef getFilename() const { return Filename; } StringRef getFilename() const { return Filename; }
Show All 10 Linespublic:
bool empty() const { return Segments.empty(); } bool empty() const { return Segments.empty(); }
/// Expansions that can be further processed. /// Expansions that can be further processed.
ArrayRef<ExpansionRecord> getExpansions() const { return Expansions; } ArrayRef<ExpansionRecord> getExpansions() const { return Expansions; }
/// Branches that can be further processed. /// Branches that can be further processed.
ArrayRef<CountedRegion> getBranches() const { return BranchRegions; } ArrayRef<CountedRegion> getBranches() const { return BranchRegions; }
/// MCDC Records that can be further processed.
ArrayRef<MCDCRecord> getMCDCRecords() const { return MCDCRecords; }
}; };
/// The mapping of profile information to coverage data. /// The mapping of profile information to coverage data.
/// ///
/// This is the main interface to get coverage information, using a profile to /// This is the main interface to get coverage information, using a profile to
/// fill out execution counts. /// fill out execution counts.
class CoverageMapping { class CoverageMapping {
DenseMap<size_t, DenseSet<size_t>> RecordProvenance; DenseMap<size_t, DenseSet<size_t>> RecordProvenance;
▲ Show 20 Lines • Show All 428 Lines • ▼ Show 20 Linesenum CovMapVersion {
Version3 = 2, Version3 = 2,
// Function records are named, uniqued, and moved to a dedicated section. // Function records are named, uniqued, and moved to a dedicated section.
Version4 = 3, Version4 = 3,
// Branch regions referring to two counters are added // Branch regions referring to two counters are added
Version5 = 4, Version5 = 4,
// Compilation directory is stored separately and combined with relative // Compilation directory is stored separately and combined with relative
// filenames to produce an absolute file path. // filenames to produce an absolute file path.
Version6 = 5, Version6 = 5,
// The current version is Version6. // Branch regions extended and Decision Regions added for MC/DC.
Version7 = 6,
// The current version is Version7.
CurrentVersion = INSTR_PROF_COVMAP_VERSION CurrentVersion = INSTR_PROF_COVMAP_VERSION
}; };
template <int CovMapVersion, class IntPtrT> struct CovMapTraits { template <int CovMapVersion, class IntPtrT> struct CovMapTraits {
using CovMapFuncRecordType = CovMapFunctionRecordV3; using CovMapFuncRecordType = CovMapFunctionRecordV3;
using NameRefType = uint64_t; using NameRefType = uint64_t;
}; };
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/include/llvm/ProfileData/InstrProf.h

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
inline StringRef getInstrProfNameVarPrefix() { return "__profn_"; } inline StringRef getInstrProfNameVarPrefix() { return "__profn_"; }
/// Return the name prefix of variables containing per-function control data. /// Return the name prefix of variables containing per-function control data.
inline StringRef getInstrProfDataVarPrefix() { return "__profd_"; } inline StringRef getInstrProfDataVarPrefix() { return "__profd_"; }
/// Return the name prefix of profile counter variables. /// Return the name prefix of profile counter variables.
inline StringRef getInstrProfCountersVarPrefix() { return "__profc_"; } inline StringRef getInstrProfCountersVarPrefix() { return "__profc_"; }
/// Return the name prefix of profile counter variables.
inline StringRef getInstrProfBitmaskVarPrefix() { return "__profbm_"; }
/// Return the name prefix of value profile variables. /// Return the name prefix of value profile variables.
inline StringRef getInstrProfValuesVarPrefix() { return "__profvp_"; } inline StringRef getInstrProfValuesVarPrefix() { return "__profvp_"; }
/// Return the name of value profile node array variables: /// Return the name of value profile node array variables:
inline StringRef getInstrProfVNodesVarName() { return "__llvm_prf_vnodes"; } inline StringRef getInstrProfVNodesVarName() { return "__llvm_prf_vnodes"; }
/// Return the name of the variable holding the strings (possibly compressed) /// Return the name of the variable holding the strings (possibly compressed)
/// of all function's PGO names. /// of all function's PGO names.
▲ Show 20 Lines • Show All 212 Lines • ▼ Show 20 Linesenum class instrprof_error {
malformed, malformed,
missing_debug_info_for_correlation, missing_debug_info_for_correlation,
unexpected_debug_info_for_correlation, unexpected_debug_info_for_correlation,
unable_to_correlate_profile, unable_to_correlate_profile,
unknown_function, unknown_function,
invalid_prof, invalid_prof,
hash_mismatch, hash_mismatch,
count_mismatch, count_mismatch,
bitmask_mismatch,
counter_overflow, counter_overflow,
value_site_count_mismatch, value_site_count_mismatch,
compress_failed, compress_failed,
uncompress_failed, uncompress_failed,
empty_raw_profile, empty_raw_profile,
zlib_unavailable zlib_unavailable,
missing_section
}; };
inline std::error_code make_error_code(instrprof_error E) { inline std::error_code make_error_code(instrprof_error E) {
return std::error_code(static_cast<int>(E), instrprof_category()); return std::error_code(static_cast<int>(E), instrprof_category());
} }
class InstrProfError : public ErrorInfo<InstrProfError> { class InstrProfError : public ErrorInfo<InstrProfError> {
public: public:
▲ Show 20 Lines • Show All 384 Lines • ▼ Show 20 Linesstruct InstrProfValueSiteRecord {
/// Compute the overlap b/w this record and Input record. /// Compute the overlap b/w this record and Input record.
void overlap(InstrProfValueSiteRecord &Input, uint32_t ValueKind, void overlap(InstrProfValueSiteRecord &Input, uint32_t ValueKind,
OverlapStats &Overlap, OverlapStats &FuncLevelOverlap); OverlapStats &Overlap, OverlapStats &FuncLevelOverlap);
}; };
/// Profiling information for a single function. /// Profiling information for a single function.
struct InstrProfRecord { struct InstrProfRecord {
std::vector<uint64_t> Counts; std::vector<uint64_t> Counts;
std::vector<uint8_t> BitmaskBytes;
InstrProfRecord() = default; InstrProfRecord() = default;
InstrProfRecord(std::vector<uint64_t> Counts) : Counts(std::move(Counts)) {} InstrProfRecord(std::vector<uint64_t> Counts) : Counts(std::move(Counts)) {}
InstrProfRecord(std::vector<uint64_t> Counts,
std::vector<uint8_t> BitmaskBytes)
: Counts(std::move(Counts)), BitmaskBytes(std::move(BitmaskBytes)) {}
InstrProfRecord(InstrProfRecord &&) = default; InstrProfRecord(InstrProfRecord &&) = default;
InstrProfRecord(const InstrProfRecord &RHS) InstrProfRecord(const InstrProfRecord &RHS)
: Counts(RHS.Counts), : Counts(RHS.Counts), BitmaskBytes(RHS.BitmaskBytes),
ValueData(RHS.ValueData ValueData(RHS.ValueData
? std::make_unique<ValueProfData>(*RHS.ValueData) ? std::make_unique<ValueProfData>(*RHS.ValueData)
: nullptr) {} : nullptr) {}
InstrProfRecord &operator=(InstrProfRecord &&) = default; InstrProfRecord &operator=(InstrProfRecord &&) = default;
InstrProfRecord &operator=(const InstrProfRecord &RHS) { InstrProfRecord &operator=(const InstrProfRecord &RHS) {
Counts = RHS.Counts; Counts = RHS.Counts;
BitmaskBytes = RHS.BitmaskBytes;
if (!RHS.ValueData) { if (!RHS.ValueData) {
ValueData = nullptr; ValueData = nullptr;
return *this; return *this;
} }
if (!ValueData) if (!ValueData)
ValueData = std::make_unique<ValueProfData>(*RHS.ValueData); ValueData = std::make_unique<ValueProfData>(*RHS.ValueData);
else else
*ValueData = *RHS.ValueData; *ValueData = *RHS.ValueData;
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Linesstruct NamedInstrProfRecord : InstrProfRecord {
// We reserve this bit as the flag for context sensitive profile record. // We reserve this bit as the flag for context sensitive profile record.
static const int CS_FLAG_IN_FUNC_HASH = 60; static const int CS_FLAG_IN_FUNC_HASH = 60;
NamedInstrProfRecord() = default; NamedInstrProfRecord() = default;
NamedInstrProfRecord(StringRef Name, uint64_t Hash, NamedInstrProfRecord(StringRef Name, uint64_t Hash,
std::vector<uint64_t> Counts) std::vector<uint64_t> Counts)
: InstrProfRecord(std::move(Counts)), Name(Name), Hash(Hash) {} : InstrProfRecord(std::move(Counts)), Name(Name), Hash(Hash) {}
NamedInstrProfRecord(StringRef Name, uint64_t Hash,
std::vector<uint64_t> Counts,
std::vector<uint8_t> BitmaskBytes)
: InstrProfRecord(std::move(Counts), std::move(BitmaskBytes)), Name(Name),
Hash(Hash) {}
static bool hasCSFlagInHash(uint64_t FuncHash) { static bool hasCSFlagInHash(uint64_t FuncHash) {
return ((FuncHash >> CS_FLAG_IN_FUNC_HASH) & 1); return ((FuncHash >> CS_FLAG_IN_FUNC_HASH) & 1);
} }
static void setCSFlagInHash(uint64_t &FuncHash) { static void setCSFlagInHash(uint64_t &FuncHash) {
FuncHash |= ((uint64_t)1 << CS_FLAG_IN_FUNC_HASH); FuncHash |= ((uint64_t)1 << CS_FLAG_IN_FUNC_HASH);
} }
}; };
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Linesenum ProfVersion {
Version5 = 5, Version5 = 5,
// In this version, the frontend PGO stable hash algorithm got fixed and // In this version, the frontend PGO stable hash algorithm got fixed and
// may produce hashes different from Version5. // may produce hashes different from Version5.
Version6 = 6, Version6 = 6,
// An additional counter is added around logical operators. // An additional counter is added around logical operators.
Version7 = 7, Version7 = 7,
// An additional (optional) memory profile type is added. // An additional (optional) memory profile type is added.
Version8 = 8, Version8 = 8,
// The current version is 8. // An additional field is used for bitmask bytes.
Version9 = 9,
// The current version is 9.
CurrentVersion = INSTR_PROF_INDEX_VERSION CurrentVersion = INSTR_PROF_INDEX_VERSION
}; };
const uint64_t Version = ProfVersion::CurrentVersion; const uint64_t Version = ProfVersion::CurrentVersion;
const HashT HashType = HashT::MD5; const HashT HashType = HashT::MD5;
inline uint64_t ComputeHash(StringRef K) { return ComputeHash(HashType, K); } inline uint64_t ComputeHash(StringRef K) { return ComputeHash(HashType, K); }
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

llvm/include/llvm/ProfileData/InstrProfCorrelator.h

Show First 20 Lines • Show All 131 Lines • ▼ Show 20 Linesprotected:
Error correlateProfileData() override; Error correlateProfileData() override;
virtual void correlateProfileDataImpl( virtual void correlateProfileDataImpl(
InstrProfCorrelator::CorrelationData *Data = nullptr) = 0; InstrProfCorrelator::CorrelationData *Data = nullptr) = 0;
Error dumpYaml(raw_ostream &OS) override; Error dumpYaml(raw_ostream &OS) override;
void addProbe(StringRef FunctionName, uint64_t CFGHash, IntPtrT CounterOffset, void addProbe(StringRef FunctionName, uint64_t CFGHash, IntPtrT CounterOffset,
IntPtrT FunctionPtr, uint32_t NumCounters); IntPtrT BitmaskOffset, IntPtrT FunctionPtr,
uint32_t NumCounters, uint32_t NumBitmaskBytes);
private: private:
InstrProfCorrelatorImpl(InstrProfCorrelatorKind Kind, InstrProfCorrelatorImpl(InstrProfCorrelatorKind Kind,
std::unique_ptr<InstrProfCorrelator::Context> Ctx) std::unique_ptr<InstrProfCorrelator::Context> Ctx)
: InstrProfCorrelator(Kind, std::move(Ctx)){}; : InstrProfCorrelator(Kind, std::move(Ctx)){};
llvm::DenseSet<IntPtrT> CounterOffsets; llvm::DenseSet<IntPtrT> CounterOffsets;
// Byte-swap the value if necessary. // Byte-swap the value if necessary.
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/include/llvm/ProfileData/InstrProfData.inc

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
#endif #endif
INSTR_PROF_DATA(const uint64_t, llvm::Type::getInt64Ty(Ctx), NameRef, \ INSTR_PROF_DATA(const uint64_t, llvm::Type::getInt64Ty(Ctx), NameRef, \
ConstantInt::get(llvm::Type::getInt64Ty(Ctx), \ ConstantInt::get(llvm::Type::getInt64Ty(Ctx), \
IndexedInstrProf::ComputeHash(getPGOFuncNameVarInitializer(Inc->getName())))) IndexedInstrProf::ComputeHash(getPGOFuncNameVarInitializer(Inc->getName()))))
INSTR_PROF_DATA(const uint64_t, llvm::Type::getInt64Ty(Ctx), FuncHash, \ INSTR_PROF_DATA(const uint64_t, llvm::Type::getInt64Ty(Ctx), FuncHash, \
ConstantInt::get(llvm::Type::getInt64Ty(Ctx), \ ConstantInt::get(llvm::Type::getInt64Ty(Ctx), \
Inc->getHash()->getZExtValue())) Inc->getHash()->getZExtValue()))
INSTR_PROF_DATA(const IntPtrT, IntPtrTy, CounterPtr, RelativeCounterPtr) INSTR_PROF_DATA(const IntPtrT, IntPtrTy, CounterPtr, RelativeCounterPtr)
INSTR_PROF_DATA(const IntPtrT, IntPtrTy, BitmaskPtr, RelativeBitmaskPtr)
/* This is used to map function pointers for the indirect call targets to /* This is used to map function pointers for the indirect call targets to
* function name hashes during the conversion from raw to merged profile * function name hashes during the conversion from raw to merged profile
* data. * data.
*/ */
INSTR_PROF_DATA(const IntPtrT, llvm::Type::getInt8PtrTy(Ctx), FunctionPointer, \ INSTR_PROF_DATA(const IntPtrT, llvm::Type::getInt8PtrTy(Ctx), FunctionPointer, \
FunctionAddr) FunctionAddr)
INSTR_PROF_DATA(IntPtrT, llvm::Type::getInt8PtrTy(Ctx), Values, \ INSTR_PROF_DATA(IntPtrT, llvm::Type::getInt8PtrTy(Ctx), Values, \
ValuesPtrExpr) ValuesPtrExpr)
INSTR_PROF_DATA(const uint32_t, llvm::Type::getInt32Ty(Ctx), NumCounters, \ INSTR_PROF_DATA(const uint32_t, llvm::Type::getInt32Ty(Ctx), NumCounters, \
ConstantInt::get(llvm::Type::getInt32Ty(Ctx), NumCounters)) ConstantInt::get(llvm::Type::getInt32Ty(Ctx), NumCounters))
INSTR_PROF_DATA(const uint16_t, Int16ArrayTy, NumValueSites[IPVK_Last+1], \ INSTR_PROF_DATA(const uint16_t, Int16ArrayTy, NumValueSites[IPVK_Last+1], \
ConstantArray::get(Int16ArrayTy, Int16ArrayVals)) ConstantArray::get(Int16ArrayTy, Int16ArrayVals)) \
INSTR_PROF_DATA(const uint32_t, llvm::Type::getInt32Ty(Ctx), NumBitmaskBytes, \
ConstantInt::get(llvm::Type::getInt32Ty(Ctx), NumBitmaskBytes))
#undef INSTR_PROF_DATA #undef INSTR_PROF_DATA
/* INSTR_PROF_DATA end. */ /* INSTR_PROF_DATA end. */
/* This is an internal data structure used by value profiler. It /* This is an internal data structure used by value profiler. It
* is defined here to allow serialization code sharing by LLVM * is defined here to allow serialization code sharing by LLVM
* to be used in unit test. * to be used in unit test.
* *
Show All 30 Lines
INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version()) INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version())
INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL)) INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL))
/* FIXME: A more accurate name is NumData */ /* FIXME: A more accurate name is NumData */
INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize) INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize)
INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesBeforeCounters, PaddingBytesBeforeCounters) INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesBeforeCounters, PaddingBytesBeforeCounters)
/* FIXME: A more accurate name is NumCounters */ /* FIXME: A more accurate name is NumCounters */
INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize) INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize)
INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesAfterCounters, PaddingBytesAfterCounters) INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesAfterCounters, PaddingBytesAfterCounters)
INSTR_PROF_RAW_HEADER(uint64_t, NumBitmaskBytes, NumBitmaskBytes)
INSTR_PROF_RAW_HEADER(uint64_t, PaddingBytesAfterBitmaskBytes, PaddingBytesAfterBitmaskBytes)
INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize) INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize)
INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta,
(uintptr_t)CountersBegin - (uintptr_t)DataBegin) (uintptr_t)CountersBegin - (uintptr_t)DataBegin)
INSTR_PROF_RAW_HEADER(uint64_t, BitmaskDelta,
(uintptr_t)BitmaskBegin - (uintptr_t)DataBegin)
INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin) INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin)
INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last) INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last)
#undef INSTR_PROF_RAW_HEADER #undef INSTR_PROF_RAW_HEADER
/* INSTR_PROF_RAW_HEADER end */ /* INSTR_PROF_RAW_HEADER end */
/* VALUE_PROF_FUNC_PARAM start */ /* VALUE_PROF_FUNC_PARAM start */
/* Definition of parameter types of the runtime API used to do value profiling /* Definition of parameter types of the runtime API used to do value profiling
* for a given value site. * for a given value site.
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Lines
#ifdef INSTR_PROF_SECT_ENTRY #ifdef INSTR_PROF_SECT_ENTRY
#define INSTR_PROF_DATA_DEFINED #define INSTR_PROF_DATA_DEFINED
INSTR_PROF_SECT_ENTRY(IPSK_data, \ INSTR_PROF_SECT_ENTRY(IPSK_data, \
INSTR_PROF_QUOTE(INSTR_PROF_DATA_COMMON), \ INSTR_PROF_QUOTE(INSTR_PROF_DATA_COMMON), \
INSTR_PROF_DATA_COFF, "__DATA,") INSTR_PROF_DATA_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_cnts, \ INSTR_PROF_SECT_ENTRY(IPSK_cnts, \
INSTR_PROF_QUOTE(INSTR_PROF_CNTS_COMMON), \ INSTR_PROF_QUOTE(INSTR_PROF_CNTS_COMMON), \
INSTR_PROF_CNTS_COFF, "__DATA,") INSTR_PROF_CNTS_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_bitmask, \
INSTR_PROF_QUOTE(INSTR_PROF_BITS_COMMON), \
INSTR_PROF_BITS_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_name, \ INSTR_PROF_SECT_ENTRY(IPSK_name, \
INSTR_PROF_QUOTE(INSTR_PROF_NAME_COMMON), \ INSTR_PROF_QUOTE(INSTR_PROF_NAME_COMMON), \
INSTR_PROF_NAME_COFF, "__DATA,") INSTR_PROF_NAME_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_vals, \ INSTR_PROF_SECT_ENTRY(IPSK_vals, \
INSTR_PROF_QUOTE(INSTR_PROF_VALS_COMMON), \ INSTR_PROF_QUOTE(INSTR_PROF_VALS_COMMON), \
INSTR_PROF_VALS_COFF, "__DATA,") INSTR_PROF_VALS_COFF, "__DATA,")
INSTR_PROF_SECT_ENTRY(IPSK_vnodes, \ INSTR_PROF_SECT_ENTRY(IPSK_vnodes, \
INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COMMON), \ INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COMMON), \
▲ Show 20 Lines • Show All 365 Lines • ▼ Show 20 Lines
#define INSTR_PROF_RAW_MAGIC_32 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \ #define INSTR_PROF_RAW_MAGIC_32 (uint64_t)255 << 56 | (uint64_t)'l' << 48 | \
(uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 | \ (uint64_t)'p' << 40 | (uint64_t)'r' << 32 | (uint64_t)'o' << 24 | \
(uint64_t)'f' << 16 | (uint64_t)'R' << 8 | (uint64_t)129 (uint64_t)'f' << 16 | (uint64_t)'R' << 8 | (uint64_t)129
/* FIXME: Please remedy the fixme in the header before bumping the version. */ /* FIXME: Please remedy the fixme in the header before bumping the version. */
/* Raw profile format version (start from 1). */ /* Raw profile format version (start from 1). */
#define INSTR_PROF_RAW_VERSION 8 #define INSTR_PROF_RAW_VERSION 8
/* Indexed profile format version (start from 1). */ /* Indexed profile format version (start from 1). */
#define INSTR_PROF_INDEX_VERSION 8 #define INSTR_PROF_INDEX_VERSION 9
/* Coverage mapping format version (start from 0). */ /* Coverage mapping format version (start from 0). */
#define INSTR_PROF_COVMAP_VERSION 5 #define INSTR_PROF_COVMAP_VERSION 6
/* Profile version is always of type uint64_t. Reserve the upper 8 bits in the /* Profile version is always of type uint64_t. Reserve the upper 8 bits in the
* version for other variants of profile. We set the lowest bit of the upper 8 * version for other variants of profile. We set the lowest bit of the upper 8
* bits (i.e. bit 56) to 1 to indicate if this is an IR-level instrumentation * bits (i.e. bit 56) to 1 to indicate if this is an IR-level instrumentation
* generated profile, and 0 if this is a Clang FE generated profile. * generated profile, and 0 if this is a Clang FE generated profile.
* 1 in bit 57 indicates there are context-sensitive records in the profile. * 1 in bit 57 indicates there are context-sensitive records in the profile.
* The 59th bit indicates whether to use debug info to correlate profiles. * The 59th bit indicates whether to use debug info to correlate profiles.
* The 60th bit indicates single byte coverage instrumentation. * The 60th bit indicates single byte coverage instrumentation.
Show All 17 Lines
* specified via command line. */ * specified via command line. */
#define INSTR_PROF_PROFILE_NAME_VAR __llvm_profile_filename #define INSTR_PROF_PROFILE_NAME_VAR __llvm_profile_filename
/* section name strings common to all targets other /* section name strings common to all targets other
than WIN32 */ than WIN32 */
#define INSTR_PROF_DATA_COMMON __llvm_prf_data #define INSTR_PROF_DATA_COMMON __llvm_prf_data
#define INSTR_PROF_NAME_COMMON __llvm_prf_names #define INSTR_PROF_NAME_COMMON __llvm_prf_names
#define INSTR_PROF_CNTS_COMMON __llvm_prf_cnts #define INSTR_PROF_CNTS_COMMON __llvm_prf_cnts
#define INSTR_PROF_BITS_COMMON __llvm_prf_bits
#define INSTR_PROF_VALS_COMMON __llvm_prf_vals #define INSTR_PROF_VALS_COMMON __llvm_prf_vals
#define INSTR_PROF_VNODES_COMMON __llvm_prf_vnds #define INSTR_PROF_VNODES_COMMON __llvm_prf_vnds
#define INSTR_PROF_COVMAP_COMMON __llvm_covmap #define INSTR_PROF_COVMAP_COMMON __llvm_covmap
#define INSTR_PROF_COVFUN_COMMON __llvm_covfun #define INSTR_PROF_COVFUN_COMMON __llvm_covfun
#define INSTR_PROF_ORDERFILE_COMMON __llvm_orderfile #define INSTR_PROF_ORDERFILE_COMMON __llvm_orderfile
/* Windows section names. Because these section names contain dollar characters, /* Windows section names. Because these section names contain dollar characters,
* they must be quoted. * they must be quoted.
*/ */
#define INSTR_PROF_DATA_COFF ".lprfd$M" #define INSTR_PROF_DATA_COFF ".lprfd$M"
#define INSTR_PROF_NAME_COFF ".lprfn$M" #define INSTR_PROF_NAME_COFF ".lprfn$M"
#define INSTR_PROF_CNTS_COFF ".lprfc$M" #define INSTR_PROF_CNTS_COFF ".lprfc$M"
#define INSTR_PROF_BITS_COFF ".lprfb$M"
#define INSTR_PROF_VALS_COFF ".lprfv$M" #define INSTR_PROF_VALS_COFF ".lprfv$M"
#define INSTR_PROF_VNODES_COFF ".lprfnd$M" #define INSTR_PROF_VNODES_COFF ".lprfnd$M"
#define INSTR_PROF_COVMAP_COFF ".lcovmap$M" #define INSTR_PROF_COVMAP_COFF ".lcovmap$M"
#define INSTR_PROF_COVFUN_COFF ".lcovfun$M" #define INSTR_PROF_COVFUN_COFF ".lcovfun$M"
#define INSTR_PROF_ORDERFILE_COFF ".lorderfile$M" #define INSTR_PROF_ORDERFILE_COFF ".lorderfile$M"
#ifdef _WIN32 #ifdef _WIN32
/* Runtime section names and name strings. */ /* Runtime section names and name strings. */
#define INSTR_PROF_DATA_SECT_NAME INSTR_PROF_DATA_COFF #define INSTR_PROF_DATA_SECT_NAME INSTR_PROF_DATA_COFF
#define INSTR_PROF_NAME_SECT_NAME INSTR_PROF_NAME_COFF #define INSTR_PROF_NAME_SECT_NAME INSTR_PROF_NAME_COFF
#define INSTR_PROF_CNTS_SECT_NAME INSTR_PROF_CNTS_COFF #define INSTR_PROF_CNTS_SECT_NAME INSTR_PROF_CNTS_COFF
#define INSTR_PROF_BITS_SECT_NAME INSTR_PROF_BITS_COFF
/* Array of pointers. Each pointer points to a list /* Array of pointers. Each pointer points to a list
* of value nodes associated with one value site. * of value nodes associated with one value site.
*/ */
#define INSTR_PROF_VALS_SECT_NAME INSTR_PROF_VALS_COFF #define INSTR_PROF_VALS_SECT_NAME INSTR_PROF_VALS_COFF
/* Value profile nodes section. */ /* Value profile nodes section. */
#define INSTR_PROF_VNODES_SECT_NAME INSTR_PROF_VNODES_COFF #define INSTR_PROF_VNODES_SECT_NAME INSTR_PROF_VNODES_COFF
#define INSTR_PROF_COVMAP_SECT_NAME INSTR_PROF_COVMAP_COFF #define INSTR_PROF_COVMAP_SECT_NAME INSTR_PROF_COVMAP_COFF
#define INSTR_PROF_COVFUN_SECT_NAME INSTR_PROF_COVFUN_COFF #define INSTR_PROF_COVFUN_SECT_NAME INSTR_PROF_COVFUN_COFF
#define INSTR_PROF_ORDERFILE_SECT_NAME INSTR_PROF_ORDERFILE_COFF #define INSTR_PROF_ORDERFILE_SECT_NAME INSTR_PROF_ORDERFILE_COFF
#else #else
/* Runtime section names and name strings. */ /* Runtime section names and name strings. */
#define INSTR_PROF_DATA_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_DATA_COMMON) #define INSTR_PROF_DATA_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_DATA_COMMON)
#define INSTR_PROF_NAME_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_NAME_COMMON) #define INSTR_PROF_NAME_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_NAME_COMMON)
#define INSTR_PROF_CNTS_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_CNTS_COMMON) #define INSTR_PROF_CNTS_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_CNTS_COMMON)
#define INSTR_PROF_BITS_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_BITS_COMMON)
/* Array of pointers. Each pointer points to a list /* Array of pointers. Each pointer points to a list
* of value nodes associated with one value site. * of value nodes associated with one value site.
*/ */
#define INSTR_PROF_VALS_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_VALS_COMMON) #define INSTR_PROF_VALS_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_VALS_COMMON)
/* Value profile nodes section. */ /* Value profile nodes section. */
#define INSTR_PROF_VNODES_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COMMON) #define INSTR_PROF_VNODES_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_VNODES_COMMON)
#define INSTR_PROF_COVMAP_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_COVMAP_COMMON) #define INSTR_PROF_COVMAP_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_COVMAP_COMMON)
#define INSTR_PROF_COVFUN_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_COVFUN_COMMON) #define INSTR_PROF_COVFUN_SECT_NAME INSTR_PROF_QUOTE(INSTR_PROF_COVFUN_COMMON)
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

llvm/include/llvm/ProfileData/InstrProfReader.h

Show First 20 Lines • Show All 276 Lines • ▼ Show 20 Linesprivate:
/// instrumentation data to their functions. /// instrumentation data to their functions.
const InstrProfCorrelatorImpl<IntPtrT> *Correlator; const InstrProfCorrelatorImpl<IntPtrT> *Correlator;
bool ShouldSwapBytes; bool ShouldSwapBytes;
// The value of the version field of the raw profile data header. The lower 56 // The value of the version field of the raw profile data header. The lower 56
// bits specifies the format version and the most significant 8 bits specify // bits specifies the format version and the most significant 8 bits specify
// the variant types of the profile. // the variant types of the profile.
uint64_t Version; uint64_t Version;
uint64_t CountersDelta; uint64_t CountersDelta;
uint64_t BitmaskDelta;
uint64_t NamesDelta; uint64_t NamesDelta;
const RawInstrProf::ProfileData<IntPtrT> *Data; const RawInstrProf::ProfileData<IntPtrT> *Data;
const RawInstrProf::ProfileData<IntPtrT> *DataEnd; const RawInstrProf::ProfileData<IntPtrT> *DataEnd;
const char *CountersStart; const char *CountersStart;
const char *CountersEnd; const char *CountersEnd;
const char *BitmaskStart;
const char *BitmaskEnd;
const char *NamesStart; const char *NamesStart;
const char *NamesEnd; const char *NamesEnd;
// After value profile is all read, this pointer points to // After value profile is all read, this pointer points to
// the header of next profile data (if exists) // the header of next profile data (if exists)
const uint8_t *ValueDataStart; const uint8_t *ValueDataStart;
uint32_t ValueKindLast; uint32_t ValueKindLast;
uint32_t CurValueDataSize; uint32_t CurValueDataSize;
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Linesprivate:
inline uint8_t getNumPaddingBytes(uint64_t SizeInBytes) { inline uint8_t getNumPaddingBytes(uint64_t SizeInBytes) {
return 7 & (sizeof(uint64_t) - SizeInBytes % sizeof(uint64_t)); return 7 & (sizeof(uint64_t) - SizeInBytes % sizeof(uint64_t));
} }
Error readName(NamedInstrProfRecord &Record); Error readName(NamedInstrProfRecord &Record);
Error readFuncHash(NamedInstrProfRecord &Record); Error readFuncHash(NamedInstrProfRecord &Record);
Error readRawCounts(InstrProfRecord &Record); Error readRawCounts(InstrProfRecord &Record);
Error readRawBitmaskBytes(InstrProfRecord &Record);
Error readValueProfilingData(InstrProfRecord &Record); Error readValueProfilingData(InstrProfRecord &Record);
bool atEnd() const { return Data == DataEnd; } bool atEnd() const { return Data == DataEnd; }
void advanceData() { void advanceData() {
// `CountersDelta` is a constant zero when using debug info correlation. // `CountersDelta` is a constant zero when using debug info correlation.
if (!Correlator) { if (!Correlator) {
// The initial CountersDelta is the in-memory address difference between // The initial CountersDelta is the in-memory address difference between
// the data and counts sections: // the data and counts sections:
// start(__llvm_prf_cnts) - start(__llvm_prf_data) // start(__llvm_prf_cnts) - start(__llvm_prf_data)
// As we advance to the next record, we maintain the correct CountersDelta // As we advance to the next record, we maintain the correct CountersDelta
// with respect to the next record. // with respect to the next record.
CountersDelta -= sizeof(*Data); CountersDelta -= sizeof(*Data);
BitmaskDelta -= sizeof(*Data);
} }
Data++; Data++;
ValueDataStart += CurValueDataSize; ValueDataStart += CurValueDataSize;
} }
const char *getNextHeaderPos() const { const char *getNextHeaderPos() const {
assert(atEnd()); assert(atEnd());
return (const char *)ValueDataStart; return (const char *)ValueDataStart;
▲ Show 20 Lines • Show All 259 Lines • ▼ Show 20 Linespublic:
/// Return the memprof record for the function identified by /// Return the memprof record for the function identified by
/// llvm::md5(Name). /// llvm::md5(Name).
Expected<memprof::MemProfRecord> getMemProfRecord(uint64_t FuncNameHash); Expected<memprof::MemProfRecord> getMemProfRecord(uint64_t FuncNameHash);
/// Fill Counts with the profile data for the given function name. /// Fill Counts with the profile data for the given function name.
Error getFunctionCounts(StringRef FuncName, uint64_t FuncHash, Error getFunctionCounts(StringRef FuncName, uint64_t FuncHash,
std::vector<uint64_t> &Counts); std::vector<uint64_t> &Counts);
/// Fill Bitmask Bytes with the profile data for the given function name.
Error getFunctionBitmaskBytes(StringRef FuncName, uint64_t FuncHash,
std::vector<uint8_t> &BitmaskBytes);
/// Return the maximum of all known function counts. /// Return the maximum of all known function counts.
/// \c UseCS indicates whether to use the context-sensitive count. /// \c UseCS indicates whether to use the context-sensitive count.
uint64_t getMaximumFunctionCount(bool UseCS) { uint64_t getMaximumFunctionCount(bool UseCS) {
if (UseCS) { if (UseCS) {
assert(CS_Summary && "No context sensitive profile summary"); assert(CS_Summary && "No context sensitive profile summary");
return CS_Summary->getMaxFunctionCount(); return CS_Summary->getMaxFunctionCount();
} else { } else {
assert(Summary && "No profile summary"); assert(Summary && "No profile summary");
Show All 38 Lines

llvm/include/llvm/Transforms/Instrumentation/InstrProfiling.h

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesprivate:
InstrProfOptions Options; InstrProfOptions Options;
Module *M; Module *M;
Triple TT; Triple TT;
std::function<const TargetLibraryInfo &(Function &F)> GetTLI; std::function<const TargetLibraryInfo &(Function &F)> GetTLI;
struct PerFunctionProfileData { struct PerFunctionProfileData {
uint32_t NumValueSites[IPVK_Last + 1]; uint32_t NumValueSites[IPVK_Last + 1];
GlobalVariable *RegionCounters = nullptr; GlobalVariable *RegionCounters = nullptr;
GlobalVariable *DataVar = nullptr; GlobalVariable *DataVar = nullptr;
GlobalVariable *RegionBitmasks = nullptr;
PerFunctionProfileData() { PerFunctionProfileData() {
memset(NumValueSites, 0, sizeof(uint32_t) * (IPVK_Last + 1)); memset(NumValueSites, 0, sizeof(uint32_t) * (IPVK_Last + 1));
} }
}; };
DenseMap<GlobalVariable *, PerFunctionProfileData> ProfileDataMap; DenseMap<GlobalVariable *, PerFunctionProfileData> ProfileDataMap;
/// If runtime relocation is enabled, this maps functions to the load /// If runtime relocation is enabled, this maps functions to the load
/// instruction that produces the profile relocation bias. /// instruction that produces the profile relocation bias.
Show All 35 Linesprivate:
void lowerCover(InstrProfCoverInst *Inc); void lowerCover(InstrProfCoverInst *Inc);
/// Replace instrprof.increment with an increment of the appropriate value. /// Replace instrprof.increment with an increment of the appropriate value.
void lowerIncrement(InstrProfIncrementInst *Inc); void lowerIncrement(InstrProfIncrementInst *Inc);
/// Force emitting of name vars for unused functions. /// Force emitting of name vars for unused functions.
void lowerCoverageData(GlobalVariable *CoverageNamesVar); void lowerCoverageData(GlobalVariable *CoverageNamesVar);
/// Replace instrprof.mcdc.bitmask.update with a shift and or instruction
/// using the index represented by the a temp value into a bitmask.
void lowerMCDCBitmaskUpdate(InstrProfMCDCBitmaskUpdate *Ins);
/// Replace instrprof.mcdc.temp.update with a shift and or instruction using
/// the corresponding condition ID.
void lowerMCDCTempUpdate(InstrProfMCDCTempUpdate *Ins);
/// Compute the address of the counter value that this profiling instruction /// Compute the address of the counter value that this profiling instruction
/// acts on. /// acts on.
Value *getCounterAddress(InstrProfInstBase *I); Value *getCounterAddress(InstrProfInstBase *I);
/// Get the region counters for an increment, creating them if necessary. /// Get the region counters for an increment, creating them if necessary.
/// ///
/// If the counter array doesn't yet exist, the profile data variables /// If the counter array doesn't yet exist, the profile data variables
/// referring to them will also be created. /// referring to them will also be created.
GlobalVariable *getOrCreateRegionCounters(InstrProfInstBase *Inc); GlobalVariable *getOrCreateRegionCounters(InstrProfInstBase *Inc);
/// Create the region counters. /// Create the region counters.
GlobalVariable *createRegionCounters(InstrProfInstBase *Inc, StringRef Name, GlobalVariable *createRegionCounters(InstrProfInstBase *Inc, StringRef Name,
GlobalValue::LinkageTypes Linkage); GlobalValue::LinkageTypes Linkage);
/// Compute the address of the bitmask value that this profiling instruction
/// acts on.
Value *getBitmaskAddress(InstrProfMCDCBitmaskUpdate *I);
/// Get the region bitmasks for an increment, creating them if necessary.
///
/// If the bitmask array doesn't yet exist, the profile data variables
/// referring to them will also be created.
GlobalVariable *getOrCreateRegionBitmasks(InstrProfInstBase *Inc);
/// Create the region bitmasks.
GlobalVariable *createRegionBitmasks(InstrProfInstBase *Inc, StringRef Name,
GlobalValue::LinkageTypes Linkage);
/// Set Comdat property of GV, if required.
void maybeSetComdat(GlobalVariable *GV, Function *Fn, StringRef VarName);
/// Setup the sections into which counters and bitmasks are allocated.
GlobalVariable *setupProfileSection(InstrProfInstBase *Inc,
InstrProfSectKind IPSK);
/// Create INSTR_PROF_DATA variable for counters and bitmasks.
void createDataVariable(InstrProfInstBase *Inc, InstrProfInstBase *Update);
/// Emit the section with compressed function names. /// Emit the section with compressed function names.
void emitNameData(); void emitNameData();
/// Emit value nodes section for value profiling. /// Emit value nodes section for value profiling.
void emitVNodes(); void emitVNodes();
/// Emit runtime registration functions for each profile data variable. /// Emit runtime registration functions for each profile data variable.
void emitRegistration(); void emitRegistration();
Show All 16 Lines

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,979 Lines • ▼ Show 20 Lines case Intrinsic::experimental_gc_relocate:
visitGCRelocate(cast<GCRelocateInst>(I)); visitGCRelocate(cast<GCRelocateInst>(I));
return; return;
case Intrinsic::instrprof_cover: case Intrinsic::instrprof_cover:
llvm_unreachable("instrprof failed to lower a cover"); llvm_unreachable("instrprof failed to lower a cover");
case Intrinsic::instrprof_increment: case Intrinsic::instrprof_increment:
llvm_unreachable("instrprof failed to lower an increment"); llvm_unreachable("instrprof failed to lower an increment");
case Intrinsic::instrprof_value_profile: case Intrinsic::instrprof_value_profile:
llvm_unreachable("instrprof failed to lower a value profiling call"); llvm_unreachable("instrprof failed to lower a value profiling call");
case Intrinsic::instrprof_mcdc_bitmask_update:
llvm_unreachable("instrprof failed to lower an mcdc bitmask update");
case Intrinsic::instrprof_mcdc_temp_update:
llvm_unreachable("instrprof failed to lower an mcdc tempval update");
case Intrinsic::localescape: { case Intrinsic::localescape: {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
const TargetInstrInfo *TII = DAG.getSubtarget().getInstrInfo(); const TargetInstrInfo *TII = DAG.getSubtarget().getInstrInfo();
// Directly emit some LOCAL_ESCAPE machine instrs. Label assignment emission // Directly emit some LOCAL_ESCAPE machine instrs. Label assignment emission
// is the same on all targets. // is the same on all targets.
for (unsigned Idx = 0, E = I.arg_size(); Idx < E; ++Idx) { for (unsigned Idx = 0, E = I.arg_size(); Idx < E; ++Idx) {
Value *Arg = I.getArgOperand(Idx)->stripPointerCasts(); Value *Arg = I.getArgOperand(Idx)->stripPointerCasts();
▲ Show 20 Lines • Show All 4,525 Lines • Show Last 20 Lines

llvm/lib/IR/IntrinsicInst.cpp

Show First 20 Lines • Show All 224 Lines • ▼ Show 20 LinesValue *InstrProfIncrementInst::getStep() const {
if (InstrProfIncrementInstStep::classof(this)) { if (InstrProfIncrementInstStep::classof(this)) {
return const_cast<Value *>(getArgOperand(4)); return const_cast<Value *>(getArgOperand(4));
} }
const Module *M = getModule(); const Module *M = getModule();
LLVMContext &Context = M->getContext(); LLVMContext &Context = M->getContext();
return ConstantInt::get(Type::getInt64Ty(Context), 1); return ConstantInt::get(Type::getInt64Ty(Context), 1);
} }
ConstantInt *InstrProfInstBase::getNumBitmaskBytes() const {
return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
}
Optional<RoundingMode> ConstrainedFPIntrinsic::getRoundingMode() const { Optional<RoundingMode> ConstrainedFPIntrinsic::getRoundingMode() const {
unsigned NumOperands = arg_size(); unsigned NumOperands = arg_size();
Metadata *MD = nullptr; Metadata *MD = nullptr;
auto *MAV = dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 2)); auto *MAV = dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 2));
if (MAV) if (MAV)
MD = MAV->getMetadata(); MD = MAV->getMetadata();
if (!MD || !isa<MDString>(MD)) if (!MD || !isa<MDString>(MD))
return None; return None;
▲ Show 20 Lines • Show All 531 Lines • Show Last 20 Lines

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Lines case Counter::Expression: {
if (!RHS) if (!RHS)
return RHS; return RHS;
return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS; return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS;
} }
} }
llvm_unreachable("Unhandled CounterKind"); llvm_unreachable("Unhandled CounterKind");
} }
Expected<BitVector> CounterMappingContext::evaluateBitmask(unsigned ID,
unsigned NC) const {
unsigned SizeInBits = llvm::alignTo(1L << NC, CHAR_BIT);
unsigned SizeInBytes = SizeInBits / CHAR_BIT;
ArrayRef<uint8_t> Bytes(&BitmaskBytes[ID], SizeInBytes);
// Mask each bitmask byte into the BitVector. Go in reverse so that the
// bitvector can just be shifted over by one byte on each iteration.
BitVector Result(SizeInBits, false);
for (auto byte = std::rbegin(Bytes); byte != std::rend(Bytes); ++byte) {
uint32_t data = *byte;
Result <<= CHAR_BIT;
Result.setBitsInMask(&data, 1);
}
return Result;
}
class MCDCRecordProcessor {
BitVector &Bitmask;
CounterMappingRegion &Region;
ArrayRef<CounterMappingRegion> Branches;
unsigned NumConditions;
llvm::DenseMap<unsigned, const CounterMappingRegion *> Map;
MCDCRecord::BoolVector Folded;
MCDCRecord::TVPairMap IndepPairs;
MCDCRecord::TestVectors TestVectors;
MCDCRecord::TestVectors ExecVectors;
public:
MCDCRecordProcessor(BitVector &Bitmask, CounterMappingRegion &Region,
ArrayRef<CounterMappingRegion> Branches)
: Bitmask(Bitmask), Region(Region), Branches(Branches),
NumConditions(Region.NumConditions), Folded(NumConditions, false),
IndepPairs(NumConditions), TestVectors(pow(2, NumConditions)) {}
private:
void recordTestVector(MCDCRecord::TestVector &TV,
MCDCRecord::CondState Result) {
// Calculate an index that is used to identify the test vector in a vector
// of test vectors. This index also corresponds to the index values of an
// MCDC Region's bitmask (see findExecutedTestVectors()).
unsigned idx = 0;
for (auto Cond = std::rbegin(TV); Cond != std::rend(TV); ++Cond) {
idx <<= 1;
idx |= (*Cond == MCDCRecord::MCDC_True) ? 0x1 : 0x0;
}
// Copy the completed test vector to the vector of testvectors.
TestVectors[idx] = TV;
// The final value (T,F) is equal to the last non-dontcare state on the
// path (in a short-circuiting system).
TestVectors[idx].push_back(Result);
}
void buildTestVector(MCDCRecord::TestVector &TV, unsigned ID = 1) {
// Branch regions are hashed based on an ID.
const CounterMappingRegion *Branch = Map[ID];
// An ID of '0' indicates the end of a test vector, at which point, the
// test vector can be copied off, and the algorithm can keep going.
// Follow "True" Path in Test Vector.
TV[ID - 1] = MCDCRecord::MCDC_True;
if (Branch->TrueID > 0)
buildTestVector(TV, Branch->TrueID);
else
recordTestVector(TV, MCDCRecord::MCDC_True);
// Follow "False" Path in Test Vector.
TV[ID - 1] = MCDCRecord::MCDC_False;
if (Branch->FalseID > 0)
buildTestVector(TV, Branch->FalseID);
else
recordTestVector(TV, MCDCRecord::MCDC_False);
// Reset back to DontCare
TV[ID - 1] = MCDCRecord::MCDC_DontCare;
}
void findExecutedTestVectors(BitVector &Bitmask) {
// Walk the bits in the bitmask. A bit set to '1' indicates that the test
// vector at the corresponding index was executed during a test run.
for (unsigned i = 0; i < Bitmask.size(); i++)
if (Bitmask[i] == 1) {
assert(!TestVectors[i].empty() && "Test Vector doesn't exist.");
ExecVectors.push_back(TestVectors[i]);
}
}
bool matchTestVectors(unsigned Aidx, unsigned Bidx, unsigned C) {
const MCDCRecord::TestVector &A = ExecVectors[Aidx];
const MCDCRecord::TestVector &B = ExecVectors[Bidx];
// If condition values in both A and B aren't opposites, no match.
if (!((A[C] ^ B[C]) == 1))
return false;
// If the results of both A and B aren't opposites, no match.
if (!((A[NumConditions] ^ B[NumConditions]) == 1))
return false;
// If just one of the other conditions don't match, no match.
for (unsigned i = 0; i < NumConditions; i++) {
if (i == C)
continue;
if (A[i] != MCDCRecord::MCDC_DontCare &&
B[i] != MCDCRecord::MCDC_DontCare && A[i] != B[i])
return false;
}
// Otherwise, match.
return true;
}
void findIndependencePairs() {
unsigned NumTVs = ExecVectors.size();
// For each condition.
for (unsigned c = 0; c < NumConditions; c++) {
bool pair_found = false;
// For each executed test vector.
for (unsigned i = 0; !pair_found && i < NumTVs; i++) {
// Compared to every other executed test vector.
for (unsigned j = 0; !pair_found && j < NumTVs; j++) {
if (i == j)
continue;
// If a matching pair of vectors is found, record them.
if ((pair_found = matchTestVectors(i, j, c)))
IndepPairs[c] = std::make_pair(i + 1, j + 1);
}
}
}
}
public:
MCDCRecord processMCDCRecord() {
unsigned i = 0;
MCDCRecord::CondIDMap PosToID;
MCDCRecord::LineColPairMap CondLoc;
// Walk the Record's BranchRegions (representing Conditions) in order to:
// - Hash the condition based on its corresponding ID. This will be used to
// calculate the test vectors.
// - Keep a map of the condition's ordinal position (1, 2, 3, 4) to its
// actual ID. This will be used to visualize the conditions in the
// correct order.
// - Keep track of the condition source location. This will be used to
// visualize where the condition is.
// - Record whether the condition is constant folded so that we exclude it
// from being measured.
for (const auto &B : Branches) {
Map[B.ID] = &B;
PosToID[i] = B.ID - 1;
CondLoc[i] = B.startLoc();
Folded[i++] = (B.Count.isZero() && B.FalseCount.isZero());
}
// Initialize a base test vector as 'DontCare'.
MCDCRecord::TestVector TV(NumConditions, MCDCRecord::MCDC_DontCare);
// Use the base test vector to build the list of all possible test vectors.
buildTestVector(TV);
// Using Profile Bitmask from runtime, mark the executed test vectors.
findExecutedTestVectors(Bitmask);
// Compare executed test vectors against each other to find an independence
// pairs for each condition. This processing takes the most time.
findIndependencePairs();
// Record Test vectors, executed vectors, and independence pairs.
MCDCRecord Res(Region, ExecVectors, IndepPairs, Folded, PosToID, CondLoc);
return Res;
}
};
Expected<MCDCRecord> CounterMappingContext::evaluateMCDCRegion(
CounterMappingRegion Region, BitVector Bitmask,
ArrayRef<CounterMappingRegion> Branches) {
MCDCRecordProcessor MCDCProcessor(Bitmask, Region, Branches);
return MCDCProcessor.processMCDCRecord();
}
unsigned CounterMappingContext::getMaxCounterID(const Counter &C) const { unsigned CounterMappingContext::getMaxCounterID(const Counter &C) const {
switch (C.getKind()) { switch (C.getKind()) {
case Counter::Zero: case Counter::Zero:
return 0; return 0;
case Counter::CounterValueReference: case Counter::CounterValueReference:
return C.getCounterID(); return C.getCounterID();
case Counter::Expression: { case Counter::Expression: {
if (C.getExpressionID() >= Expressions.size()) if (C.getExpressionID() >= Expressions.size())
Show All 26 Linesstatic unsigned getMaxCounterID(const CounterMappingContext &Ctx,
const CoverageMappingRecord &Record) { const CoverageMappingRecord &Record) {
unsigned MaxCounterID = 0; unsigned MaxCounterID = 0;
for (const auto &Region : Record.MappingRegions) { for (const auto &Region : Record.MappingRegions) {
MaxCounterID = std::max(MaxCounterID, Ctx.getMaxCounterID(Region.Count)); MaxCounterID = std::max(MaxCounterID, Ctx.getMaxCounterID(Region.Count));
} }
return MaxCounterID; return MaxCounterID;
} }
static unsigned getMaxBitmaskSize(const CounterMappingContext &Ctx,
const CoverageMappingRecord &Record) {
unsigned MaxBitmaskID = 0;
unsigned NumConditions = 0;
// The last DecisionRegion has the highest bitmask byte index used in the
// function, which when combined with its number of conditions, yields the
// full bitmask size.
for (const auto &Region : reverse(Record.MappingRegions)) {
if (Region.Kind == CounterMappingRegion::MCDCDecisionRegion) {
MaxBitmaskID = Region.Mask;
NumConditions = Region.NumConditions;
break;
}
}
unsigned SizeInBits = llvm::alignTo(1L << NumConditions, CHAR_BIT);
return MaxBitmaskID + (SizeInBits / CHAR_BIT);
}
Error CoverageMapping::loadFunctionRecord( Error CoverageMapping::loadFunctionRecord(
const CoverageMappingRecord &Record, const CoverageMappingRecord &Record,
IndexedInstrProfReader &ProfileReader) { IndexedInstrProfReader &ProfileReader) {
StringRef OrigFuncName = Record.FunctionName; StringRef OrigFuncName = Record.FunctionName;
if (OrigFuncName.empty()) if (OrigFuncName.empty())
return make_error<CoverageMapError>(coveragemap_error::malformed); return make_error<CoverageMapError>(coveragemap_error::malformed);
if (Record.Filenames.empty()) if (Record.Filenames.empty())
Show All 12 Lines if (IPE == instrprof_error::hash_mismatch) {
Record.FunctionHash); Record.FunctionHash);
return Error::success(); return Error::success();
} else if (IPE != instrprof_error::unknown_function) } else if (IPE != instrprof_error::unknown_function)
return make_error<InstrProfError>(IPE); return make_error<InstrProfError>(IPE);
Counts.assign(getMaxCounterID(Ctx, Record) + 1, 0); Counts.assign(getMaxCounterID(Ctx, Record) + 1, 0);
} }
Ctx.setCounts(Counts); Ctx.setCounts(Counts);
std::vector<uint8_t> BitmaskBytes;
if (Error E = ProfileReader.getFunctionBitmaskBytes(
Record.FunctionName, Record.FunctionHash, BitmaskBytes)) {
instrprof_error IPE = InstrProfError::take(std::move(E));
if (IPE == instrprof_error::hash_mismatch) {
FuncHashMismatches.emplace_back(std::string(Record.FunctionName),
Record.FunctionHash);
return Error::success();
} else if (IPE != instrprof_error::unknown_function)
return make_error<InstrProfError>(IPE);
BitmaskBytes.assign(getMaxBitmaskSize(Ctx, Record) + 1, 0);
}
Ctx.setBitmaskBytes(BitmaskBytes);
assert(!Record.MappingRegions.empty() && "Function has no regions"); assert(!Record.MappingRegions.empty() && "Function has no regions");
// This coverage record is a zero region for a function that's unused in // This coverage record is a zero region for a function that's unused in
// some TU, but used in a different TU. Ignore it. The coverage maps from the // some TU, but used in a different TU. Ignore it. The coverage maps from the
// the other TU will either be loaded (providing full region counts) or they // the other TU will either be loaded (providing full region counts) or they
// won't (in which case we don't unintuitively report functions as uncovered // won't (in which case we don't unintuitively report functions as uncovered
// when they have non-zero counts in the profile). // when they have non-zero counts in the profile).
if (Record.MappingRegions.size() == 1 && if (Record.MappingRegions.size() == 1 &&
Record.MappingRegions[0].Count.isZero() && Counts[0] > 0) Record.MappingRegions[0].Count.isZero() && Counts[0] > 0)
return Error::success(); return Error::success();
unsigned NumConds = 0;
const CounterMappingRegion *MCDCDecision;
std::vector<CounterMappingRegion> MCDCBranches;
FunctionRecord Function(OrigFuncName, Record.Filenames); FunctionRecord Function(OrigFuncName, Record.Filenames);
for (const auto &Region : Record.MappingRegions) { for (const auto &Region : Record.MappingRegions) {
// If an MCDC DecisionRegion is seen, track the BranchRegions that follow
// it according to Region.NumConditions.
if (Region.Kind == CounterMappingRegion::MCDCDecisionRegion) {
assert(NumConds == 0);
MCDCDecision = &Region;
NumConds = Region.NumConditions;
continue;
}
Expected<int64_t> ExecutionCount = Ctx.evaluate(Region.Count); Expected<int64_t> ExecutionCount = Ctx.evaluate(Region.Count);
if (auto E = ExecutionCount.takeError()) { if (auto E = ExecutionCount.takeError()) {
consumeError(std::move(E)); consumeError(std::move(E));
return Error::success(); return Error::success();
} }
Expected<int64_t> AltExecutionCount = Ctx.evaluate(Region.FalseCount); Expected<int64_t> AltExecutionCount = Ctx.evaluate(Region.FalseCount);
if (auto E = AltExecutionCount.takeError()) { if (auto E = AltExecutionCount.takeError()) {
consumeError(std::move(E)); consumeError(std::move(E));
return Error::success(); return Error::success();
} }
Function.pushRegion(Region, *ExecutionCount, *AltExecutionCount); Function.pushRegion(Region, *ExecutionCount, *AltExecutionCount);
// If a MCDCDecisionRegion was seen as well as the BranchRegions that
// correspond to it stored in a vector, according to the number of
// conditions recorded for the region.
if (NumConds > 0 && Region.Kind == CounterMappingRegion::MCDCBranchRegion) {
MCDCBranches.push_back(Region);
if (--NumConds == 0) {
// Evaluating the test vector bitmask for the decision region entails
// calculating precisely what bits are pertinent to this region alone.
// This is calculated based on the recorded offset into the global
// profile bitmask; the length is calculated based on the recorded
// number of conditions.
Expected<BitVector> Bitmask = Ctx.evaluateBitmask(
MCDCDecision->Mask, MCDCDecision->NumConditions);
if (auto E = Bitmask.takeError()) {
consumeError(std::move(E));
return Error::success();
}
// Since the bitmask identifies the executed test vectors for an MC/DC
// DecisionRegion, all of the information is now available to process.
// This is where the bulk of the MC/DC progressing takes place.
Expected<MCDCRecord> Record =
Ctx.evaluateMCDCRegion(*MCDCDecision, *Bitmask, MCDCBranches);
if (auto E = Record.takeError()) {
consumeError(std::move(E));
return Error::success();
}
// Save the MC/DC Record so that it can be visualized later.
Function.pushMCDCRecord(*Record);
MCDCBranches.clear();
}
}
} }
// Don't create records for (filenames, function) pairs we've already seen. // Don't create records for (filenames, function) pairs we've already seen.
auto FilenamesHash = hash_combine_range(Record.Filenames.begin(), auto FilenamesHash = hash_combine_range(Record.Filenames.begin(),
Record.Filenames.end()); Record.Filenames.end());
if (!RecordProvenance[FilenamesHash].insert(hash_value(OrigFuncName)).second) if (!RecordProvenance[FilenamesHash].insert(hash_value(OrigFuncName)).second)
return Error::success(); return Error::success();
▲ Show 20 Lines • Show All 426 Lines • ▼ Show 20 Lines for (const auto &CR : Function.CountedRegions)
Regions.push_back(CR); Regions.push_back(CR);
if (MainFileID && isExpansion(CR, *MainFileID)) if (MainFileID && isExpansion(CR, *MainFileID))
FileCoverage.Expansions.emplace_back(CR, Function); FileCoverage.Expansions.emplace_back(CR, Function);
} }
// Capture branch regions specific to the function (excluding expansions). // Capture branch regions specific to the function (excluding expansions).
for (const auto &CR : Function.CountedBranchRegions) for (const auto &CR : Function.CountedBranchRegions)
if (FileIDs.test(CR.FileID) && (CR.FileID == CR.ExpandedFileID)) if (FileIDs.test(CR.FileID) && (CR.FileID == CR.ExpandedFileID))
FileCoverage.BranchRegions.push_back(CR); FileCoverage.BranchRegions.push_back(CR);
// Capture MCDC records specific to the function.
for (const auto &MR : Function.MCDCRecords)
if (FileIDs.test(MR.getDecisionRegion().FileID))
FileCoverage.MCDCRecords.push_back(MR);
} }
LLVM_DEBUG(dbgs() << "Emitting segments for file: " << Filename << "\n"); LLVM_DEBUG(dbgs() << "Emitting segments for file: " << Filename << "\n");
FileCoverage.Segments = SegmentBuilder::buildSegments(Regions); FileCoverage.Segments = SegmentBuilder::buildSegments(Regions);
return FileCoverage; return FileCoverage;
} }
Show All 36 Lines if (CR.FileID == *MainFileID) {
if (isExpansion(CR, *MainFileID)) if (isExpansion(CR, *MainFileID))
FunctionCoverage.Expansions.emplace_back(CR, Function); FunctionCoverage.Expansions.emplace_back(CR, Function);
} }
// Capture branch regions specific to the function (excluding expansions). // Capture branch regions specific to the function (excluding expansions).
for (const auto &CR : Function.CountedBranchRegions) for (const auto &CR : Function.CountedBranchRegions)
if (CR.FileID == *MainFileID) if (CR.FileID == *MainFileID)
FunctionCoverage.BranchRegions.push_back(CR); FunctionCoverage.BranchRegions.push_back(CR);
// Capture MCDC records specific to the function.
for (const auto &MR : Function.MCDCRecords)
if (MR.getDecisionRegion().FileID == *MainFileID)
FunctionCoverage.MCDCRecords.push_back(MR);
LLVM_DEBUG(dbgs() << "Emitting segments for function: " << Function.Name LLVM_DEBUG(dbgs() << "Emitting segments for function: " << Function.Name
<< "\n"); << "\n");
FunctionCoverage.Segments = SegmentBuilder::buildSegments(Regions); FunctionCoverage.Segments = SegmentBuilder::buildSegments(Regions);
return FunctionCoverage; return FunctionCoverage;
} }
CoverageData CoverageMapping::getCoverageForExpansion( CoverageData CoverageMapping::getCoverageForExpansion(
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

Show First 20 Lines • Show All 231 Lines • ▼ Show 20 LinesError RawCoverageMappingReader::readMappingRegionsSubArray(
std::vector<CounterMappingRegion> &MappingRegions, unsigned InferredFileID, std::vector<CounterMappingRegion> &MappingRegions, unsigned InferredFileID,
size_t NumFileIDs) { size_t NumFileIDs) {
uint64_t NumRegions; uint64_t NumRegions;
if (auto Err = readSize(NumRegions)) if (auto Err = readSize(NumRegions))
return Err; return Err;
unsigned LineStart = 0; unsigned LineStart = 0;
for (size_t I = 0; I < NumRegions; ++I) { for (size_t I = 0; I < NumRegions; ++I) {
Counter C, C2; Counter C, C2;
uint64_t Mask = 0, Conditions = 0, ID = 0, TID = 0, FID = 0;
CounterMappingRegion::RegionKind Kind = CounterMappingRegion::CodeRegion; CounterMappingRegion::RegionKind Kind = CounterMappingRegion::CodeRegion;
// Read the combined counter + region kind. // Read the combined counter + region kind.
uint64_t EncodedCounterAndRegion; uint64_t EncodedCounterAndRegion;
if (auto Err = readIntMax(EncodedCounterAndRegion, if (auto Err = readIntMax(EncodedCounterAndRegion,
std::numeric_limits<unsigned>::max())) std::numeric_limits<unsigned>::max()))
return Err; return Err;
unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask; unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
Show All 33 Lines if (Tag != Counter::Zero) {
case CounterMappingRegion::BranchRegion: case CounterMappingRegion::BranchRegion:
// For a Branch Region, read two successive counters. // For a Branch Region, read two successive counters.
Kind = CounterMappingRegion::BranchRegion; Kind = CounterMappingRegion::BranchRegion;
if (auto Err = readCounter(C)) if (auto Err = readCounter(C))
return Err; return Err;
if (auto Err = readCounter(C2)) if (auto Err = readCounter(C2))
return Err; return Err;
break; break;
case CounterMappingRegion::MCDCBranchRegion:
// For a MCDC Branch Region, read two successive counters and 3 IDs.
Kind = CounterMappingRegion::MCDCBranchRegion;
if (auto Err = readCounter(C))
return Err;
if (auto Err = readCounter(C2))
return Err;
if (auto Err = readIntMax(ID, std::numeric_limits<unsigned>::max()))
return Err;
if (auto Err = readIntMax(TID, std::numeric_limits<unsigned>::max()))
return Err;
if (auto Err = readIntMax(FID, std::numeric_limits<unsigned>::max()))
return Err;
break;
case CounterMappingRegion::MCDCDecisionRegion:
Kind = CounterMappingRegion::MCDCDecisionRegion;
if (auto Err = readIntMax(Mask, std::numeric_limits<unsigned>::max()))
return Err;
if (auto Err =
readIntMax(Conditions, std::numeric_limits<unsigned>::max()))
return Err;
break;
default: default:
return make_error<CoverageMapError>(coveragemap_error::malformed); return make_error<CoverageMapError>(coveragemap_error::malformed);
} }
} }
} }
// Read the source range. // Read the source range.
uint64_t LineStartDelta, ColumnStart, NumLines, ColumnEnd; uint64_t LineStartDelta, ColumnStart, NumLines, ColumnEnd;
Show All 35 Lines LLVM_DEBUG({
<< ColumnEnd << ", "; << ColumnEnd << ", ";
if (Kind == CounterMappingRegion::ExpansionRegion) if (Kind == CounterMappingRegion::ExpansionRegion)
dbgs() << "Expands to file " << ExpandedFileID; dbgs() << "Expands to file " << ExpandedFileID;
else else
CounterMappingContext(Expressions).dump(C, dbgs()); CounterMappingContext(Expressions).dump(C, dbgs());
dbgs() << "\n"; dbgs() << "\n";
}); });
auto CMR = CounterMappingRegion(C, C2, InferredFileID, ExpandedFileID, auto CMR = CounterMappingRegion(
LineStart, ColumnStart, C, C2, Mask, Conditions, ID, TID, FID, InferredFileID, ExpandedFileID,
LineStart + NumLines, ColumnEnd, Kind); LineStart, ColumnStart, LineStart + NumLines, ColumnEnd, Kind);
if (CMR.startLoc() > CMR.endLoc()) if (CMR.startLoc() > CMR.endLoc())
return make_error<CoverageMapError>(coveragemap_error::malformed); return make_error<CoverageMapError>(coveragemap_error::malformed);
MappingRegions.push_back(CMR); MappingRegions.push_back(CMR);
} }
return Error::success(); return Error::success();
} }
Error RawCoverageMappingReader::read() { Error RawCoverageMappingReader::read() {
▲ Show 20 Lines • Show All 401 Lines • ▼ Show 20 LinesExpected<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get(
case CovMapVersion::Version1: case CovMapVersion::Version1:
return std::make_unique<VersionedCovMapFuncRecordReader< return std::make_unique<VersionedCovMapFuncRecordReader<
CovMapVersion::Version1, IntPtrT, Endian>>(P, R, D, F); CovMapVersion::Version1, IntPtrT, Endian>>(P, R, D, F);
case CovMapVersion::Version2: case CovMapVersion::Version2:
case CovMapVersion::Version3: case CovMapVersion::Version3:
case CovMapVersion::Version4: case CovMapVersion::Version4:
case CovMapVersion::Version5: case CovMapVersion::Version5:
case CovMapVersion::Version6: case CovMapVersion::Version6:
case CovMapVersion::Version7:
// Decompress the name data. // Decompress the name data.
if (Error E = P.create(P.getNameData())) if (Error E = P.create(P.getNameData()))
return std::move(E); return std::move(E);
if (Version == CovMapVersion::Version2) if (Version == CovMapVersion::Version2)
return std::make_unique<VersionedCovMapFuncRecordReader< return std::make_unique<VersionedCovMapFuncRecordReader<
CovMapVersion::Version2, IntPtrT, Endian>>(P, R, D, F); CovMapVersion::Version2, IntPtrT, Endian>>(P, R, D, F);
else if (Version == CovMapVersion::Version3) else if (Version == CovMapVersion::Version3)
return std::make_unique<VersionedCovMapFuncRecordReader< return std::make_unique<VersionedCovMapFuncRecordReader<
CovMapVersion::Version3, IntPtrT, Endian>>(P, R, D, F); CovMapVersion::Version3, IntPtrT, Endian>>(P, R, D, F);
else if (Version == CovMapVersion::Version4) else if (Version == CovMapVersion::Version4)
return std::make_unique<VersionedCovMapFuncRecordReader< return std::make_unique<VersionedCovMapFuncRecordReader<
CovMapVersion::Version4, IntPtrT, Endian>>(P, R, D, F); CovMapVersion::Version4, IntPtrT, Endian>>(P, R, D, F);
else if (Version == CovMapVersion::Version5) else if (Version == CovMapVersion::Version5)
return std::make_unique<VersionedCovMapFuncRecordReader< return std::make_unique<VersionedCovMapFuncRecordReader<
CovMapVersion::Version5, IntPtrT, Endian>>(P, R, D, F); CovMapVersion::Version5, IntPtrT, Endian>>(P, R, D, F);
else if (Version == CovMapVersion::Version6) else if (Version == CovMapVersion::Version6)
return std::make_unique<VersionedCovMapFuncRecordReader< return std::make_unique<VersionedCovMapFuncRecordReader<
CovMapVersion::Version6, IntPtrT, Endian>>(P, R, D, F); CovMapVersion::Version6, IntPtrT, Endian>>(P, R, D, F);
else if (Version == CovMapVersion::Version7)
return std::make_unique<VersionedCovMapFuncRecordReader<
CovMapVersion::Version7, IntPtrT, Endian>>(P, R, D, F);
} }
llvm_unreachable("Unsupported version"); llvm_unreachable("Unsupported version");
} }
template <typename T, support::endianness Endian> template <typename T, support::endianness Endian>
static Error readCoverageMappingData( static Error readCoverageMappingData(
InstrProfSymtab &ProfileNames, StringRef CovMap, StringRef FuncRecords, InstrProfSymtab &ProfileNames, StringRef CovMap, StringRef FuncRecords,
std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records, std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records,
▲ Show 20 Lines • Show All 393 Lines • Show Last 20 Lines

llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp

Show First 20 Lines • Show All 230 Lines • ▼ Show 20 Lines case CounterMappingRegion::SkippedRegion:
break; break;
case CounterMappingRegion::BranchRegion: case CounterMappingRegion::BranchRegion:
encodeULEB128(unsigned(I->Kind) encodeULEB128(unsigned(I->Kind)
<< Counter::EncodingCounterTagAndExpansionRegionTagBits, << Counter::EncodingCounterTagAndExpansionRegionTagBits,
OS); OS);
writeCounter(MinExpressions, Count, OS); writeCounter(MinExpressions, Count, OS);
writeCounter(MinExpressions, FalseCount, OS); writeCounter(MinExpressions, FalseCount, OS);
break; break;
case CounterMappingRegion::MCDCBranchRegion:
encodeULEB128(unsigned(I->Kind)
<< Counter::EncodingCounterTagAndExpansionRegionTagBits,
OS);
writeCounter(MinExpressions, Count, OS);
writeCounter(MinExpressions, FalseCount, OS);
encodeULEB128(unsigned(I->ID), OS);
encodeULEB128(unsigned(I->TrueID), OS);
encodeULEB128(unsigned(I->FalseID), OS);
break;
case CounterMappingRegion::MCDCDecisionRegion:
encodeULEB128(unsigned(I->Kind)
<< Counter::EncodingCounterTagAndExpansionRegionTagBits,
OS);
encodeULEB128(unsigned(I->Mask), OS);
encodeULEB128(unsigned(I->NumConditions), OS);
break;
} }
assert(I->LineStart >= PrevLineStart); assert(I->LineStart >= PrevLineStart);
encodeULEB128(I->LineStart - PrevLineStart, OS); encodeULEB128(I->LineStart - PrevLineStart, OS);
encodeULEB128(I->ColumnStart, OS); encodeULEB128(I->ColumnStart, OS);
assert(I->LineEnd >= I->LineStart); assert(I->LineEnd >= I->LineStart);
encodeULEB128(I->LineEnd - I->LineStart, OS); encodeULEB128(I->LineEnd - I->LineStart, OS);
encodeULEB128(I->ColumnEnd, OS); encodeULEB128(I->ColumnEnd, OS);
PrevLineStart = I->LineStart; PrevLineStart = I->LineStart;
} }
// Ensure that all file ids have at least one mapping region. // Ensure that all file ids have at least one mapping region.
assert(CurrentFileID == (VirtualFileMapping.size() - 1)); assert(CurrentFileID == (VirtualFileMapping.size() - 1));
} }

llvm/lib/ProfileData/InstrProf.cpp

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Lines case instrprof_error::unknown_function:
OS << "no profile data available for function"; OS << "no profile data available for function";
break; break;
case instrprof_error::hash_mismatch: case instrprof_error::hash_mismatch:
OS << "function control flow change detected (hash mismatch)"; OS << "function control flow change detected (hash mismatch)";
break; break;
case instrprof_error::count_mismatch: case instrprof_error::count_mismatch:
OS << "function basic block count change detected (counter mismatch)"; OS << "function basic block count change detected (counter mismatch)";
break; break;
case instrprof_error::bitmask_mismatch:
OS << "function bitmask size change detected (bitmask size mismatch)";
break;
case instrprof_error::counter_overflow: case instrprof_error::counter_overflow:
OS << "counter overflow"; OS << "counter overflow";
break; break;
case instrprof_error::value_site_count_mismatch: case instrprof_error::value_site_count_mismatch:
OS << "function value site count change detected (counter mismatch)"; OS << "function value site count change detected (counter mismatch)";
break; break;
case instrprof_error::compress_failed: case instrprof_error::compress_failed:
OS << "failed to compress data (zlib)"; OS << "failed to compress data (zlib)";
break; break;
case instrprof_error::uncompress_failed: case instrprof_error::uncompress_failed:
OS << "failed to uncompress data (zlib)"; OS << "failed to uncompress data (zlib)";
break; break;
case instrprof_error::empty_raw_profile: case instrprof_error::empty_raw_profile:
OS << "empty raw profile file"; OS << "empty raw profile file";
break; break;
case instrprof_error::zlib_unavailable: case instrprof_error::zlib_unavailable:
OS << "profile uses zlib compression but the profile reader was built " OS << "profile uses zlib compression but the profile reader was built "
"without zlib support"; "without zlib support";
break; break;
case instrprof_error::missing_section:
OS << "Missing profiling data section";
break;
default:
llvm_unreachable("A value of instrprof_error has no message.");
break;
} }
// If optional error message is not empty, append it to the message. // If optional error message is not empty, append it to the message.
if (!ErrMsg.empty()) if (!ErrMsg.empty())
OS << ": " << ErrMsg; OS << ": " << ErrMsg;
return OS.str(); return OS.str();
} }
▲ Show 20 Lines • Show All 577 Lines • ▼ Show 20 Lines if (Value > getInstrMaxCountValue()) {
Value = getInstrMaxCountValue(); Value = getInstrMaxCountValue();
Overflowed = true; Overflowed = true;
} }
Counts[I] = Value; Counts[I] = Value;
if (Overflowed) if (Overflowed)
Warn(instrprof_error::counter_overflow); Warn(instrprof_error::counter_overflow);
} }
// If the number of bitmask bytes doesn't match we either have bad data
// or a hash collision.
if (BitmaskBytes.size() != Other.BitmaskBytes.size()) {
Warn(instrprof_error::bitmask_mismatch);
return;
}
// Bitmask bytes are merged by simply ORing them together.
for (size_t I = 0, E = Other.BitmaskBytes.size(); I < E; ++I) {
BitmaskBytes[I] = Other.BitmaskBytes[I] | BitmaskBytes[I];
}
for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind) for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
mergeValueProfData(Kind, Other, Weight, Warn); mergeValueProfData(Kind, Other, Weight, Warn);
} }
void InstrProfRecord::scaleValueProfData( void InstrProfRecord::scaleValueProfData(
uint32_t ValueKind, uint64_t N, uint64_t D, uint32_t ValueKind, uint64_t N, uint64_t D,
function_ref<void(instrprof_error)> Warn) { function_ref<void(instrprof_error)> Warn) {
for (auto &R : getValueSitesForKind(ValueKind)) for (auto &R : getValueSitesForKind(ValueKind))
▲ Show 20 Lines • Show All 610 Lines • ▼ Show 20 LinesExpected<Header> Header::readFromBuffer(const unsigned char *Buffer) {
if (GET_VERSION(H.formatVersion()) > if (GET_VERSION(H.formatVersion()) >
IndexedInstrProf::ProfVersion::CurrentVersion) IndexedInstrProf::ProfVersion::CurrentVersion)
return make_error<InstrProfError>(instrprof_error::unsupported_version); return make_error<InstrProfError>(instrprof_error::unsupported_version);
switch (GET_VERSION(H.formatVersion())) { switch (GET_VERSION(H.formatVersion())) {
// When a new field is added in the header add a case statement here to // When a new field is added in the header add a case statement here to
// populate it. // populate it.
static_assert( static_assert(
IndexedInstrProf::ProfVersion::CurrentVersion == Version8, IndexedInstrProf::ProfVersion::CurrentVersion == Version9,
"Please update the reading code below if a new field has been added, " "Please update the reading code below if a new field has been added, "
"if not add a case statement to fall through to the latest version."); "if not add a case statement to fall through to the latest version.");
case 9ull:
case 8ull: case 8ull:
H.MemProfOffset = read(Buffer, offsetOf(&Header::MemProfOffset)); H.MemProfOffset = read(Buffer, offsetOf(&Header::MemProfOffset));
[[fallthrough]]; [[fallthrough]];
default: // Version7 (when the backwards compatible header was introduced). default: // Version7 (when the backwards compatible header was introduced).
H.HashType = read(Buffer, offsetOf(&Header::HashType)); H.HashType = read(Buffer, offsetOf(&Header::HashType));
H.HashOffset = read(Buffer, offsetOf(&Header::HashOffset)); H.HashOffset = read(Buffer, offsetOf(&Header::HashOffset));
} }
return H; return H;
} }
size_t Header::size() const { size_t Header::size() const {
switch (GET_VERSION(formatVersion())) { switch (GET_VERSION(formatVersion())) {
// When a new field is added to the header add a case statement here to // When a new field is added to the header add a case statement here to
// compute the size as offset of the new field + size of the new field. This // compute the size as offset of the new field + size of the new field. This
// relies on the field being added to the end of the list. // relies on the field being added to the end of the list.
static_assert(IndexedInstrProf::ProfVersion::CurrentVersion == Version8, static_assert(IndexedInstrProf::ProfVersion::CurrentVersion == Version9,
"Please update the size computation below if a new field has " "Please update the size computation below if a new field has "
"been added to the header, if not add a case statement to " "been added to the header, if not add a case statement to "
"fall through to the latest version."); "fall through to the latest version.");
case 9ull:
case 8ull: case 8ull:
return offsetOf(&Header::MemProfOffset) + sizeof(Header::MemProfOffset); return offsetOf(&Header::MemProfOffset) + sizeof(Header::MemProfOffset);
default: // Version7 (when the backwards compatible header was introduced). default: // Version7 (when the backwards compatible header was introduced).
return offsetOf(&Header::HashOffset) + sizeof(Header::HashOffset); return offsetOf(&Header::HashOffset) + sizeof(Header::HashOffset);
} }
} }
} // namespace IndexedInstrProf } // namespace IndexedInstrProf
} // end namespace llvm } // end namespace llvm

llvm/lib/ProfileData/InstrProfCorrelator.cpp

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 Lines return make_error<InstrProfError>(
instrprof_error::unable_to_correlate_profile, instrprof_error::unable_to_correlate_profile,
"could not find any profile metadata in debug info"); "could not find any profile metadata in debug info");
yaml::Output YamlOS(OS); yaml::Output YamlOS(OS);
YamlOS << Data; YamlOS << Data;
return Error::success(); return Error::success();
} }
template <class IntPtrT> template <class IntPtrT>
void InstrProfCorrelatorImpl<IntPtrT>::addProbe(StringRef FunctionName, void InstrProfCorrelatorImpl<IntPtrT>::addProbe(
uint64_t CFGHash, StringRef FunctionName, uint64_t CFGHash, IntPtrT CounterOffset,
IntPtrT CounterOffset, IntPtrT BitmaskOffset, IntPtrT FunctionPtr, uint32_t NumCounters,
IntPtrT FunctionPtr, uint32_t NumBitmaskBytes) {
uint32_t NumCounters) {
// Check if a probe was already added for this counter offset. // Check if a probe was already added for this counter offset.
if (!CounterOffsets.insert(CounterOffset).second) if (!CounterOffsets.insert(CounterOffset).second)
return; return;
Data.push_back({ Data.push_back({
maybeSwap<uint64_t>(IndexedInstrProf::ComputeHash(FunctionName)), maybeSwap<uint64_t>(IndexedInstrProf::ComputeHash(FunctionName)),
maybeSwap<uint64_t>(CFGHash), maybeSwap<uint64_t>(CFGHash),
// In this mode, CounterPtr actually stores the section relative address // In this mode, CounterPtr actually stores the section relative address
// of the counter. // of the counter.
maybeSwap<IntPtrT>(CounterOffset), maybeSwap<IntPtrT>(CounterOffset),
maybeSwap<IntPtrT>(BitmaskOffset),
ellisUnsubmitted
Not Done
ReplyInline Actions

Since BitmaskOffset and NumBitmaskBytes are always zero, I would rather set them as zero here rather than passing in more parameters. See ValuesPtr.

ellis: Since `BitmaskOffset` and `NumBitmaskBytes` are always zero, I would rather set them as zero…
maybeSwap<IntPtrT>(FunctionPtr), maybeSwap<IntPtrT>(FunctionPtr),
// TODO: Value profiling is not yet supported. // TODO: Value profiling is not yet supported.
/*ValuesPtr=*/maybeSwap<IntPtrT>(0), /*ValuesPtr=*/maybeSwap<IntPtrT>(0),
maybeSwap<uint32_t>(NumCounters), maybeSwap<uint32_t>(NumCounters),
/*NumValueSites=*/{maybeSwap<uint16_t>(0), maybeSwap<uint16_t>(0)}, /*NumValueSites=*/{maybeSwap<uint16_t>(0), maybeSwap<uint16_t>(0)},
maybeSwap<uint32_t>(NumBitmaskBytes),
}); });
NamesVec.push_back(FunctionName.str()); NamesVec.push_back(FunctionName.str());
} }
template <class IntPtrT> template <class IntPtrT>
llvm::Optional<uint64_t> llvm::Optional<uint64_t>
DwarfInstrProfCorrelator<IntPtrT>::getLocation(const DWARFDie &Die) const { DwarfInstrProfCorrelator<IntPtrT>::getLocation(const DWARFDie &Die) const {
auto Locations = Die.getLocations(dwarf::DW_AT_location); auto Locations = Die.getLocations(dwarf::DW_AT_location);
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines if (Data) {
auto FilePath = FnDie.getDeclFile( auto FilePath = FnDie.getDeclFile(
DILineInfoSpecifier::FileLineInfoKind::RelativeFilePath); DILineInfoSpecifier::FileLineInfoKind::RelativeFilePath);
if (!FilePath.empty()) if (!FilePath.empty())
P.FilePath = FilePath; P.FilePath = FilePath;
if (auto LineNumber = FnDie.getDeclLine()) if (auto LineNumber = FnDie.getDeclLine())
P.LineNumber = LineNumber; P.LineNumber = LineNumber;
Data->Probes.push_back(P); Data->Probes.push_back(P);
} else { } else {
this->addProbe(*FunctionName, *CFGHash, CounterOffset, this->addProbe(*FunctionName, *CFGHash, CounterOffset, 0,
FunctionPtr.value_or(0), *NumCounters); FunctionPtr.value_or(0), *NumCounters, /*Bitmaskbytes=*/0);
} }
}; };
for (auto &CU : DICtx->normal_units()) for (auto &CU : DICtx->normal_units())
for (const auto &Entry : CU->dies()) for (const auto &Entry : CU->dies())
maybeAddProbe(DWARFDie(CU.get(), &Entry)); maybeAddProbe(DWARFDie(CU.get(), &Entry));
for (auto &CU : DICtx->dwo_units()) for (auto &CU : DICtx->dwo_units())
for (const auto &Entry : CU->dies()) for (const auto &Entry : CU->dies())
maybeAddProbe(DWARFDie(CU.get(), &Entry)); maybeAddProbe(DWARFDie(CU.get(), &Entry));
} }

llvm/lib/ProfileData/InstrProfReader.cpp

Show First 20 Lines • Show All 300 Lines • ▼ Show 20 Lines for (uint64_t I = 0; I < NumCounters; ++I) {
if (Line.is_at_end()) if (Line.is_at_end())
return error(instrprof_error::truncated); return error(instrprof_error::truncated);
uint64_t Count; uint64_t Count;
if ((Line++)->getAsInteger(10, Count)) if ((Line++)->getAsInteger(10, Count))
return error(instrprof_error::malformed, "count is invalid"); return error(instrprof_error::malformed, "count is invalid");
Record.Counts.push_back(Count); Record.Counts.push_back(Count);
} }
// Bitmask byte information is indicated with special character.
if (Line->startswith("$")) {
Record.BitmaskBytes.clear();
// Read the number of bitmask bytes.
uint64_t NumBitmaskBytes;
if ((Line++)->drop_front(1).getAsInteger(10, NumBitmaskBytes))
return error(instrprof_error::malformed,
"number of bitmasks is not a valid integer");
if (NumBitmaskBytes != 0) {
// Read each bitmask and fill our internal storage with the values.
Record.BitmaskBytes.reserve(NumBitmaskBytes);
for (uint8_t I = 0; I < NumBitmaskBytes; ++I) {
if (Line.is_at_end())
return error(instrprof_error::truncated);
uint8_t BitmaskByte;
if ((Line++)->getAsInteger(16, BitmaskByte))
return error(instrprof_error::malformed, "bitmask byte is invalid");
Record.BitmaskBytes.push_back(BitmaskByte);
}
}
}
// Check if value profile data exists and read it if so. // Check if value profile data exists and read it if so.
if (Error E = readValueProfileData(Record)) if (Error E = readValueProfileData(Record))
return error(std::move(E)); return error(std::move(E));
return success(); return success();
} }
template <class IntPtrT> template <class IntPtrT>
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 LinesError RawInstrProfReader<IntPtrT>::readHeader(
if (!useDebugInfoCorrelate() && Correlator) if (!useDebugInfoCorrelate() && Correlator)
return error(instrprof_error::unexpected_debug_info_for_correlation); return error(instrprof_error::unexpected_debug_info_for_correlation);
BinaryIdsSize = swap(Header.BinaryIdsSize); BinaryIdsSize = swap(Header.BinaryIdsSize);
if (BinaryIdsSize % sizeof(uint64_t)) if (BinaryIdsSize % sizeof(uint64_t))
return error(instrprof_error::bad_header); return error(instrprof_error::bad_header);
CountersDelta = swap(Header.CountersDelta); CountersDelta = swap(Header.CountersDelta);
BitmaskDelta = swap(Header.BitmaskDelta);
NamesDelta = swap(Header.NamesDelta); NamesDelta = swap(Header.NamesDelta);
auto NumData = swap(Header.DataSize); auto NumData = swap(Header.DataSize);
auto PaddingBytesBeforeCounters = swap(Header.PaddingBytesBeforeCounters); auto PaddingBytesBeforeCounters = swap(Header.PaddingBytesBeforeCounters);
auto CountersSize = swap(Header.CountersSize) * getCounterTypeSize(); auto CountersSize = swap(Header.CountersSize) * getCounterTypeSize();
auto PaddingBytesAfterCounters = swap(Header.PaddingBytesAfterCounters); auto PaddingBytesAfterCounters = swap(Header.PaddingBytesAfterCounters);
auto NumBitmaskBytes = swap(Header.NumBitmaskBytes);
auto PaddingBytesAfterBitmaskBytes = swap(Header.PaddingBytesAfterBitmaskBytes);
auto NamesSize = swap(Header.NamesSize); auto NamesSize = swap(Header.NamesSize);
ValueKindLast = swap(Header.ValueKindLast); ValueKindLast = swap(Header.ValueKindLast);
auto DataSize = NumData * sizeof(RawInstrProf::ProfileData<IntPtrT>); auto DataSize = NumData * sizeof(RawInstrProf::ProfileData<IntPtrT>);
auto PaddingSize = getNumPaddingBytes(NamesSize); auto PaddingSize = getNumPaddingBytes(NamesSize);
// Profile data starts after profile header and binary ids if exist. // Profile data starts after profile header and binary ids if exist.
ptrdiff_t DataOffset = sizeof(RawInstrProf::Header) + BinaryIdsSize; ptrdiff_t DataOffset = sizeof(RawInstrProf::Header) + BinaryIdsSize;
ptrdiff_t CountersOffset = DataOffset + DataSize + PaddingBytesBeforeCounters; ptrdiff_t CountersOffset = DataOffset + DataSize + PaddingBytesBeforeCounters;
ptrdiff_t BitmaskOffset = CountersOffset + CountersSize +
PaddingBytesAfterCounters;
ptrdiff_t NamesOffset = ptrdiff_t NamesOffset =
CountersOffset + CountersSize + PaddingBytesAfterCounters; BitmaskOffset + NumBitmaskBytes + PaddingBytesAfterBitmaskBytes;
ptrdiff_t ValueDataOffset = NamesOffset + NamesSize + PaddingSize; ptrdiff_t ValueDataOffset = NamesOffset + NamesSize + PaddingSize;
auto *Start = reinterpret_cast<const char *>(&Header); auto *Start = reinterpret_cast<const char *>(&Header);
if (Start + ValueDataOffset > DataBuffer->getBufferEnd()) if (Start + ValueDataOffset > DataBuffer->getBufferEnd())
return error(instrprof_error::bad_header); return error(instrprof_error::bad_header);
if (Correlator) { if (Correlator) {
// These sizes in the raw file are zero because we constructed them in the // These sizes in the raw file are zero because we constructed them in the
Show All 12 Lines if (Correlator) {
NamesEnd = NamesStart + NamesSize; NamesEnd = NamesStart + NamesSize;
} }
// Binary ids start just after the header. // Binary ids start just after the header.
BinaryIdsStart = BinaryIdsStart =
reinterpret_cast<const uint8_t *>(&Header) + sizeof(RawInstrProf::Header); reinterpret_cast<const uint8_t *>(&Header) + sizeof(RawInstrProf::Header);
CountersStart = Start + CountersOffset; CountersStart = Start + CountersOffset;
CountersEnd = CountersStart + CountersSize; CountersEnd = CountersStart + CountersSize;
BitmaskStart = Start + BitmaskOffset;
BitmaskEnd = BitmaskStart + NumBitmaskBytes;
ValueDataStart = reinterpret_cast<const uint8_t *>(Start + ValueDataOffset); ValueDataStart = reinterpret_cast<const uint8_t *>(Start + ValueDataOffset);
const uint8_t *BufferEnd = (const uint8_t *)DataBuffer->getBufferEnd(); const uint8_t *BufferEnd = (const uint8_t *)DataBuffer->getBufferEnd();
if (BinaryIdsStart + BinaryIdsSize > BufferEnd) if (BinaryIdsStart + BinaryIdsSize > BufferEnd)
return error(instrprof_error::bad_header); return error(instrprof_error::bad_header);
std::unique_ptr<InstrProfSymtab> NewSymtab = std::make_unique<InstrProfSymtab>(); std::unique_ptr<InstrProfSymtab> NewSymtab = std::make_unique<InstrProfSymtab>();
if (Error E = createSymtab(*NewSymtab)) if (Error E = createSymtab(*NewSymtab))
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines if (hasSingleByteCoverage()) {
Record.Counts.push_back(swap(*CounterValue)); Record.Counts.push_back(swap(*CounterValue));
} }
} }
return success(); return success();
} }
template <class IntPtrT> template <class IntPtrT>
Error RawInstrProfReader<IntPtrT>::readRawBitmaskBytes(
InstrProfRecord &Record) {
uint32_t NumBitmaskBytes = swap(Data->NumBitmaskBytes);
Record.BitmaskBytes.clear();
Record.BitmaskBytes.reserve(NumBitmaskBytes);
// It's possible MCDC is either not enabled or only used for some functions
// and not others. So if we record 0 bytes, just move on.
if (NumBitmaskBytes == 0) {
return success();
}
// BitmaskDelta decreases as we advance to the next data record.
ptrdiff_t BitmaskOffset = swap(Data->BitmaskPtr) - BitmaskDelta;
if (BitmaskOffset < 0)
return error(
instrprof_error::malformed,
("bitmask offset " + Twine(BitmaskOffset) + " is negative").str());
if (BitmaskOffset >= BitmaskEnd - BitmaskStart)
return error(instrprof_error::malformed,
("bitmask offset " + Twine(BitmaskOffset) +
" is greater than the maximum bitmask offset " +
Twine(BitmaskEnd - BitmaskStart - 1))
.str());
uint64_t MaxNumBitmaskBytes =
(BitmaskEnd - (BitmaskStart + BitmaskOffset)) / sizeof(uint8_t);
if (NumBitmaskBytes > MaxNumBitmaskBytes)
return error(instrprof_error::malformed,
("number of bitmask bytes " + Twine(NumBitmaskBytes) +
" is greater than the maximum number of bitmask bytes " +
Twine(MaxNumBitmaskBytes))
.str());
for (uint32_t I = 0; I < NumBitmaskBytes; I++) {
const char *Ptr = BitmaskStart + BitmaskOffset + I;
Record.BitmaskBytes.push_back(swap(*Ptr));
}
return success();
}
template <class IntPtrT>
Error RawInstrProfReader<IntPtrT>::readValueProfilingData( Error RawInstrProfReader<IntPtrT>::readValueProfilingData(
InstrProfRecord &Record) { InstrProfRecord &Record) {
Record.clearValueData(); Record.clearValueData();
CurValueDataSize = 0; CurValueDataSize = 0;
// Need to match the logic in value profile dumper code in compiler-rt: // Need to match the logic in value profile dumper code in compiler-rt:
uint32_t NumValueKinds = 0; uint32_t NumValueKinds = 0;
for (uint32_t I = 0; I < IPVK_Last + 1; I++) for (uint32_t I = 0; I < IPVK_Last + 1; I++)
NumValueKinds += (Data->NumValueSites[I] != 0); NumValueKinds += (Data->NumValueSites[I] != 0);
Show All 33 LinesError RawInstrProfReader<IntPtrT>::readNextRecord(NamedInstrProfRecord &Record) {
// Read FuncHash and set it in Record. // Read FuncHash and set it in Record.
if (Error E = readFuncHash(Record)) if (Error E = readFuncHash(Record))
return error(std::move(E)); return error(std::move(E));
// Read raw counts and set Record. // Read raw counts and set Record.
if (Error E = readRawCounts(Record)) if (Error E = readRawCounts(Record))
return error(std::move(E)); return error(std::move(E));
// Read raw bitmask bytes and set Record.
if (Error E = readRawBitmaskBytes(Record))
return error(std::move(E));
// Read value data and set Record. // Read value data and set Record.
if (Error E = readValueProfilingData(Record)) if (Error E = readValueProfilingData(Record))
return error(std::move(E)); return error(std::move(E));
// Iterate. // Iterate.
advanceData(); advanceData();
return success(); return success();
} }
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Linesdata_type InstrProfLookupTrait::ReadData(StringRef K, const unsigned char *D,
using namespace support; using namespace support;
// Check if the data is corrupt. If so, don't try to read it. // Check if the data is corrupt. If so, don't try to read it.
if (N % sizeof(uint64_t)) if (N % sizeof(uint64_t))
return data_type(); return data_type();
DataBuffer.clear(); DataBuffer.clear();
std::vector<uint64_t> CounterBuffer; std::vector<uint64_t> CounterBuffer;
std::vector<uint8_t> BitmaskByteBuffer;
const unsigned char *End = D + N; const unsigned char *End = D + N;
while (D < End) { while (D < End) {
// Read hash. // Read hash.
if (D + sizeof(uint64_t) >= End) if (D + sizeof(uint64_t) >= End)
return data_type(); return data_type();
uint64_t Hash = endian::readNext<uint64_t, little, unaligned>(D); uint64_t Hash = endian::readNext<uint64_t, little, unaligned>(D);
Show All 9 Lines while (D < End) {
if (D + CountsSize * sizeof(uint64_t) > End) if (D + CountsSize * sizeof(uint64_t) > End)
return data_type(); return data_type();
CounterBuffer.clear(); CounterBuffer.clear();
CounterBuffer.reserve(CountsSize); CounterBuffer.reserve(CountsSize);
for (uint64_t J = 0; J < CountsSize; ++J) for (uint64_t J = 0; J < CountsSize; ++J)
CounterBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D)); CounterBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D));
DataBuffer.emplace_back(K, Hash, std::move(CounterBuffer)); // Read bitmask bytes for GET_VERSION(FormatVersion) > 8.
if (GET_VERSION(FormatVersion) > IndexedInstrProf::ProfVersion::Version8) {
uint64_t BitmaskBytes = 0;
if (D + sizeof(uint64_t) > End)
return data_type();
BitmaskBytes = endian::readNext<uint64_t, little, unaligned>(D);
// Read bitmask byte values.
if (D + BitmaskBytes * sizeof(uint8_t) > End)
return data_type();
BitmaskByteBuffer.clear();
BitmaskByteBuffer.reserve(BitmaskBytes);
for (uint64_t J = 0; J < BitmaskBytes; ++J)
BitmaskByteBuffer.push_back(static_cast<uint8_t>(
endian::readNext<uint64_t, little, unaligned>(D)));
}
DataBuffer.emplace_back(K, Hash, std::move(CounterBuffer),
std::move(BitmaskByteBuffer));
// Read value profiling data. // Read value profiling data.
if (GET_VERSION(FormatVersion) > IndexedInstrProf::ProfVersion::Version2 && if (GET_VERSION(FormatVersion) > IndexedInstrProf::ProfVersion::Version2 &&
!readValueProfilingData(D, End)) { !readValueProfilingData(D, End)) {
DataBuffer.clear(); DataBuffer.clear();
return data_type(); return data_type();
} }
} }
▲ Show 20 Lines • Show All 417 Lines • ▼ Show 20 LinesError IndexedInstrProfReader::getFunctionCounts(StringRef FuncName,
Expected<InstrProfRecord> Record = getInstrProfRecord(FuncName, FuncHash); Expected<InstrProfRecord> Record = getInstrProfRecord(FuncName, FuncHash);
if (Error E = Record.takeError()) if (Error E = Record.takeError())
return error(std::move(E)); return error(std::move(E));
Counts = Record.get().Counts; Counts = Record.get().Counts;
return success(); return success();
} }
Error IndexedInstrProfReader::getFunctionBitmaskBytes(
StringRef FuncName, uint64_t FuncHash, std::vector<uint8_t> &BitmaskBytes) {
Expected<InstrProfRecord> Record = getInstrProfRecord(FuncName, FuncHash);
if (Error E = Record.takeError())
return error(std::move(E));
BitmaskBytes = Record.get().BitmaskBytes;
return success();
}
Error IndexedInstrProfReader::readNextRecord(NamedInstrProfRecord &Record) { Error IndexedInstrProfReader::readNextRecord(NamedInstrProfRecord &Record) {
ArrayRef<NamedInstrProfRecord> Data; ArrayRef<NamedInstrProfRecord> Data;
Error E = Index->getRecords(Data); Error E = Index->getRecords(Data);
if (E) if (E)
return error(std::move(E)); return error(std::move(E));
Record = Data[RecordIndex++]; Record = Data[RecordIndex++];
Show All 20 Lines

llvm/lib/ProfileData/InstrProfWriter.cpp

Show First 20 Lines • Show All 123 Lines • ▼ Show 20 Lines EmitKeyDataLength(raw_ostream &Out, key_type_ref K, data_type_ref V) {
LE.write<offset_type>(N); LE.write<offset_type>(N);
offset_type M = 0; offset_type M = 0;
for (const auto &ProfileData : *V) { for (const auto &ProfileData : *V) {
const InstrProfRecord &ProfRecord = ProfileData.second; const InstrProfRecord &ProfRecord = ProfileData.second;
M += sizeof(uint64_t); // The function hash M += sizeof(uint64_t); // The function hash
M += sizeof(uint64_t); // The size of the Counts vector M += sizeof(uint64_t); // The size of the Counts vector
M += ProfRecord.Counts.size() * sizeof(uint64_t); M += ProfRecord.Counts.size() * sizeof(uint64_t);
M += sizeof(uint64_t); // The size of the Bitmask vector
M += ProfRecord.BitmaskBytes.size() * sizeof(uint64_t);
// Value data // Value data
M += ValueProfData::getSize(ProfileData.second); M += ValueProfData::getSize(ProfileData.second);
} }
LE.write<offset_type>(M); LE.write<offset_type>(M);
return std::make_pair(N, M); return std::make_pair(N, M);
} }
Show All 13 Lines for (const auto &ProfileData : *V) {
else else
SummaryBuilder->addRecord(ProfRecord); SummaryBuilder->addRecord(ProfRecord);
LE.write<uint64_t>(ProfileData.first); // Function hash LE.write<uint64_t>(ProfileData.first); // Function hash
LE.write<uint64_t>(ProfRecord.Counts.size()); LE.write<uint64_t>(ProfRecord.Counts.size());
for (uint64_t I : ProfRecord.Counts) for (uint64_t I : ProfRecord.Counts)
LE.write<uint64_t>(I); LE.write<uint64_t>(I);
LE.write<uint64_t>(ProfRecord.BitmaskBytes.size());
for (uint64_t I : ProfRecord.BitmaskBytes)
LE.write<uint64_t>(I);
// Write value data // Write value data
std::unique_ptr<ValueProfData> VDataPtr = std::unique_ptr<ValueProfData> VDataPtr =
ValueProfData::serializeFrom(ProfileData.second); ValueProfData::serializeFrom(ProfileData.second);
uint32_t S = VDataPtr->getSize(); uint32_t S = VDataPtr->getSize();
VDataPtr->swapBytesFromHost(ValueProfDataEndianness); VDataPtr->swapBytesFromHost(ValueProfDataEndianness);
Out.write((const char *)VDataPtr.get(), S); Out.write((const char *)VDataPtr.get(), S);
} }
} }
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Lines
bool InstrProfWriter::shouldEncodeData(const ProfilingData &PD) { bool InstrProfWriter::shouldEncodeData(const ProfilingData &PD) {
if (!Sparse) if (!Sparse)
return true; return true;
for (const auto &Func : PD) { for (const auto &Func : PD) {
const InstrProfRecord &IPR = Func.second; const InstrProfRecord &IPR = Func.second;
if (llvm::any_of(IPR.Counts, [](uint64_t Count) { return Count > 0; })) if (llvm::any_of(IPR.Counts, [](uint64_t Count) { return Count > 0; }))
return true; return true;
if (llvm::any_of(IPR.BitmaskBytes, [](uint8_t Byte) { return Byte > 0; }))
return true;
} }
return false; return false;
} }
static void setSummary(IndexedInstrProf::Summary *TheSummary, static void setSummary(IndexedInstrProf::Summary *TheSummary,
ProfileSummary &PS) { ProfileSummary &PS) {
using namespace IndexedInstrProf; using namespace IndexedInstrProf;
▲ Show 20 Lines • Show All 231 Lines • ▼ Show 20 Linesvoid InstrProfWriter::writeRecordInText(StringRef Name, uint64_t Hash,
raw_fd_ostream &OS) { raw_fd_ostream &OS) {
OS << Name << "\n"; OS << Name << "\n";
OS << "# Func Hash:\n" << Hash << "\n"; OS << "# Func Hash:\n" << Hash << "\n";
OS << "# Num Counters:\n" << Func.Counts.size() << "\n"; OS << "# Num Counters:\n" << Func.Counts.size() << "\n";
OS << "# Counter Values:\n"; OS << "# Counter Values:\n";
for (uint64_t Count : Func.Counts) for (uint64_t Count : Func.Counts)
OS << Count << "\n"; OS << Count << "\n";
if (Func.BitmaskBytes.size() > 0) {
OS << "# Num Bitmask Bytes:\n$" << Func.BitmaskBytes.size() << "\n";
OS << "# Bitmask Byte Values:\n";
for (uint8_t Byte : Func.BitmaskBytes) {
OS.write_hex(Byte);
OS << "\n";
}
OS << "\n";
}
uint32_t NumValueKinds = Func.getNumValueKinds(); uint32_t NumValueKinds = Func.getNumValueKinds();
if (!NumValueKinds) { if (!NumValueKinds) {
OS << "\n"; OS << "\n";
return; return;
} }
OS << "# Num Value Kinds:\n" << Func.getNumValueKinds() << "\n"; OS << "# Num Value Kinds:\n" << Func.getNumValueKinds() << "\n";
for (uint32_t VK = 0; VK < IPVK_Last + 1; VK++) { for (uint32_t VK = 0; VK < IPVK_Last + 1; VK++) {
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

Show First 20 Lines • Show All 421 Lines • ▼ Show 20 Lines for (Instruction &Instr : llvm::make_early_inc_range(BB)) {
lowerIncrement(IPI); lowerIncrement(IPI);
MadeChange = true; MadeChange = true;
} else if (auto *IPC = dyn_cast<InstrProfCoverInst>(&Instr)) { } else if (auto *IPC = dyn_cast<InstrProfCoverInst>(&Instr)) {
lowerCover(IPC); lowerCover(IPC);
MadeChange = true; MadeChange = true;
} else if (auto *IPVP = dyn_cast<InstrProfValueProfileInst>(&Instr)) { } else if (auto *IPVP = dyn_cast<InstrProfValueProfileInst>(&Instr)) {
lowerValueProfileInst(IPVP); lowerValueProfileInst(IPVP);
MadeChange = true; MadeChange = true;
} else if (auto *IPMP = dyn_cast<InstrProfMCDCParameters>(&Instr)) {
IPMP->eraseFromParent();
MadeChange = true;
} else if (auto *IPBU = dyn_cast<InstrProfMCDCBitmaskUpdate>(&Instr)) {
lowerMCDCBitmaskUpdate(IPBU);
MadeChange = true;
} else if (auto *IPTU = dyn_cast<InstrProfMCDCTempUpdate>(&Instr)) {
lowerMCDCTempUpdate(IPTU);
MadeChange = true;
} }
} }
} }
if (!MadeChange) if (!MadeChange)
return false; return false;
promoteCounterLoadStores(F); promoteCounterLoadStores(F);
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Linesbool InstrProfiling::run(
// Improve compile time by avoiding linear scans when there is no work. // Improve compile time by avoiding linear scans when there is no work.
if (!ContainsProfiling && !CoverageNamesVar) if (!ContainsProfiling && !CoverageNamesVar)
return MadeChange; return MadeChange;
// We did not know how many value sites there would be inside // We did not know how many value sites there would be inside
// the instrumented function. This is counting the number of instrumented // the instrumented function. This is counting the number of instrumented
// target value sites to enter it as field in the profile data variable. // target value sites to enter it as field in the profile data variable.
for (Function &F : M) { for (Function &F : M) {
InstrProfCoverInst *FirstProfCoverInst = nullptr;
InstrProfIncrementInst *FirstProfIncInst = nullptr; InstrProfIncrementInst *FirstProfIncInst = nullptr;
for (BasicBlock &BB : F) InstrProfMCDCParameters *FirstProfMCDCParameters = nullptr;
for (auto I = BB.begin(), E = BB.end(); I != E; I++) for (BasicBlock &BB : F) {
for (auto I = BB.begin(), E = BB.end(); I != E; I++) {
if (auto *Ind = dyn_cast<InstrProfValueProfileInst>(I)) if (auto *Ind = dyn_cast<InstrProfValueProfileInst>(I))
computeNumValueSiteCounts(Ind); computeNumValueSiteCounts(Ind);
else if (FirstProfIncInst == nullptr) else {
if (FirstProfCoverInst == nullptr)
FirstProfCoverInst = dyn_cast<InstrProfCoverInst>(I);
if (FirstProfIncInst == nullptr)
FirstProfIncInst = dyn_cast<InstrProfIncrementInst>(I); FirstProfIncInst = dyn_cast<InstrProfIncrementInst>(I);
if (FirstProfMCDCParameters == nullptr)
FirstProfMCDCParameters = dyn_cast<InstrProfMCDCParameters>(I);
}
}
}
// If the MCDCParameters intrinsic was seen, create the bitmasks.
if (FirstProfMCDCParameters != nullptr) {
static_cast<void>(getOrCreateRegionBitmasks(FirstProfMCDCParameters));
}
// Value profiling intrinsic lowering requires per-function profile data // If an Increment Intrinsic was seen, use that to create the region
// variable to be created first. // counters and data variable. Otherwise, use the Cover Intrinsic. Also
// create the data variable based on the MCDCParameters.
InstrProfInstBase *BaseInst = nullptr;
if (FirstProfIncInst != nullptr) if (FirstProfIncInst != nullptr)
static_cast<void>(getOrCreateRegionCounters(FirstProfIncInst)); BaseInst = FirstProfIncInst;
else
BaseInst = FirstProfCoverInst;
if (BaseInst != nullptr) {
static_cast<void>(getOrCreateRegionCounters(BaseInst));
createDataVariable(BaseInst, FirstProfMCDCParameters);
}
} }
for (Function &F : M) for (Function &F : M)
MadeChange |= lowerIntrinsics(&F); MadeChange |= lowerIntrinsics(&F);
if (CoverageNamesVar) { if (CoverageNamesVar) {
lowerCoverageData(CoverageNamesVar); lowerCoverageData(CoverageNamesVar);
MadeChange = true; MadeChange = true;
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines if (!Bias) {
Bias->setComdat(M->getOrInsertComdat(Bias->getName())); Bias->setComdat(M->getOrInsertComdat(Bias->getName()));
} }
BiasLI = EntryBuilder.CreateLoad(Int64Ty, Bias); BiasLI = EntryBuilder.CreateLoad(Int64Ty, Bias);
} }
auto *Add = Builder.CreateAdd(Builder.CreatePtrToInt(Addr, Int64Ty), BiasLI); auto *Add = Builder.CreateAdd(Builder.CreatePtrToInt(Addr, Int64Ty), BiasLI);
return Builder.CreateIntToPtr(Add, Addr->getType()); return Builder.CreateIntToPtr(Add, Addr->getType());
} }
Value *InstrProfiling::getBitmaskAddress(InstrProfMCDCBitmaskUpdate *I) {
auto *Bitmasks = getOrCreateRegionBitmasks(I);
IRBuilder<> Builder(I);
auto *Addr =
Builder.CreateConstInBoundsGEP2_32(Bitmasks->getValueType(), Bitmasks, 0,
I->getBitmaskIndex()->getZExtValue());
// TODO: May need to support runtime counter relocation for bitmasks prior to
// upstreaming. See getCounterAddress().
return Addr;
}
void InstrProfiling::lowerCover(InstrProfCoverInst *CoverInstruction) { void InstrProfiling::lowerCover(InstrProfCoverInst *CoverInstruction) {
auto *Addr = getCounterAddress(CoverInstruction); auto *Addr = getCounterAddress(CoverInstruction);
IRBuilder<> Builder(CoverInstruction); IRBuilder<> Builder(CoverInstruction);
// We store zero to represent that this block is covered. // We store zero to represent that this block is covered.
Builder.CreateStore(Builder.getInt8(0), Addr); Builder.CreateStore(Builder.getInt8(0), Addr);
CoverInstruction->eraseFromParent(); CoverInstruction->eraseFromParent();
} }
Show All 28 Lines for (unsigned I = 0, E = Names->getNumOperands(); I < E; ++I) {
Name->setLinkage(GlobalValue::PrivateLinkage); Name->setLinkage(GlobalValue::PrivateLinkage);
ReferencedNames.push_back(Name); ReferencedNames.push_back(Name);
if (isa<ConstantExpr>(NC)) if (isa<ConstantExpr>(NC))
NC->dropAllReferences(); NC->dropAllReferences();
} }
CoverageNamesVar->eraseFromParent(); CoverageNamesVar->eraseFromParent();
} }
void InstrProfiling::lowerMCDCBitmaskUpdate(
InstrProfMCDCBitmaskUpdate *Update) {
IRBuilder<> Builder(Update);
auto *Int8Ty = Type::getInt8Ty(M->getContext());
auto *Int8PtrTy = Type::getInt8PtrTy(M->getContext());
auto *Int32Ty = Type::getInt32Ty(M->getContext());
auto *Int64Ty = Type::getInt64Ty(M->getContext());
auto *TempAddr = Update->getTempAddr();
auto *BitmaskAddr = getBitmaskAddress(Update);
// Load Temp Val.
// %mcdc.temp = load i32, ptr %mcdc.addr, align 4
auto *Temp = Builder.CreateLoad(Int32Ty, TempAddr, "mcdc.temp");
// Calculate byte offset using div8.
// %1 = lshr i32 %mcdc.temp, 3
auto *BitmaskByteOffset = Builder.CreateLShr(Temp, 0x3);
// Add byte offset to section base byte address.
// %2 = zext i32 %1 to i64
// %3 = add i64 ptrtoint (ptr @__profbm_test to i64), %2
auto *BitmaskByteAddr = Builder.CreateAdd(
Builder.CreatePtrToInt(BitmaskAddr, Int64Ty),
Builder.CreateZExtOrBitCast(BitmaskByteOffset, Int64Ty));
// Convert to a pointer.
// %4 = inttoptr i32 %3 to ptr
BitmaskByteAddr = Builder.CreateIntToPtr(BitmaskByteAddr, Int8PtrTy);
// Calculate bit offset into bitmask byte by using div8 remainder (AND ~8)
// %5 = and i32 %mcdc.temp, 7
// %6 = trunc i32 %5 to i8
auto *BitToSet = Builder.CreateTrunc(Builder.CreateAnd(Temp, 0x7), Int8Ty);
// Shift bit offset left to form a bitmask.
// %7 = shl i8 1, %6
auto *ShiftedVal = Builder.CreateShl(Builder.getInt8(0x1), BitToSet);
// Load profile bitmask byte.
// %mcdc.bits = load i8, ptr %4, align 1
auto *Bitmask = Builder.CreateLoad(Int8Ty, BitmaskByteAddr, "mcdc.bits");
// Perform logical OR of profile bitmask byte and shifted bit offset.
// %8 = or i8 %mcdc.bits, %7
auto *Result = Builder.CreateOr(Bitmask, ShiftedVal);
// Store the updated profile bitmask byte.
// store i8 %8, ptr %3, align 1
Builder.CreateStore(Result, BitmaskByteAddr);
Update->eraseFromParent();
}
void InstrProfiling::lowerMCDCTempUpdate(InstrProfMCDCTempUpdate *Update) {
IRBuilder<> Builder(Update);
auto *Int32Ty = Type::getInt32Ty(M->getContext());
auto *Addr = Update->getTempAddr();
// Load the MCDC temporary value from the stack.
// %mcdc.temp = load i32, ptr %mcdc.addr, align 4
auto *Temp = Builder.CreateLoad(Int32Ty, Addr, "mcdc.temp");
// Zero-extend the evaluated condition boolean value (0 or 1) by 32bits.
// %1 = zext i1 %tobool to i32
auto *CondV_32 = Builder.CreateZExt(Update->getCondBool(), Int32Ty);
// Shift the boolean value left (by the condition's ID) to form a bitmask.
// %2 = shl i32 %1, <Update->getCondID()>
auto *ShiftedVal = Builder.CreateShl(CondV_32, Update->getCondID());
// Perform logical OR of the bitmask against the loaded MCDC temporary value.
// %3 = or i32 %mcdc.temp, %2
auto *Result = Builder.CreateOr(Temp, ShiftedVal);
// Store the updated temporary value back to the stack.
// store i32 %3, ptr %mcdc.addr, align 4
Builder.CreateStore(Result, Addr);
Update->eraseFromParent();
}
/// Get the name of a profiling variable for a particular function. /// Get the name of a profiling variable for a particular function.
static std::string getVarName(InstrProfInstBase *Inc, StringRef Prefix, static std::string getVarName(InstrProfInstBase *Inc, StringRef Prefix,
bool &Renamed) { bool &Renamed) {
StringRef NamePrefix = getInstrProfNameVarPrefix(); StringRef NamePrefix = getInstrProfNameVarPrefix();
StringRef Name = Inc->getName()->getName().substr(NamePrefix.size()); StringRef Name = Inc->getName()->getName().substr(NamePrefix.size());
Function *F = Inc->getParent()->getParent(); Function *F = Inc->getParent()->getParent();
Module *M = F->getParent(); Module *M = F->getParent();
if (!DoHashBasedCounterSplit || !isIRPGOFlagSet(M) || if (!DoHashBasedCounterSplit || !isIRPGOFlagSet(M) ||
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Linesstatic bool needsRuntimeRegistrationOfSectionRange(const Triple &TT) {
// Use linker script magic to get data/cnts/name start/end. // Use linker script magic to get data/cnts/name start/end.
if (TT.isOSAIX() || TT.isOSLinux() || TT.isOSFreeBSD() || TT.isOSNetBSD() || if (TT.isOSAIX() || TT.isOSLinux() || TT.isOSFreeBSD() || TT.isOSNetBSD() ||
TT.isOSSolaris() || TT.isOSFuchsia() || TT.isPS() || TT.isOSWindows()) TT.isOSSolaris() || TT.isOSFuchsia() || TT.isPS() || TT.isOSWindows())
return false; return false;
return true; return true;
} }
GlobalVariable * void InstrProfiling::maybeSetComdat(GlobalVariable *GV, Function *Fn,
InstrProfiling::createRegionCounters(InstrProfInstBase *Inc, StringRef Name, StringRef VarName) {
GlobalValue::LinkageTypes Linkage) { bool DataReferencedByCode = profDataReferencedByCode(*M);
uint64_t NumCounters = Inc->getNumCounters()->getZExtValue(); bool NeedComdat = needsComdatForCounter(*Fn, *M);
auto &Ctx = M->getContext(); bool UseComdat = (NeedComdat || TT.isOSBinFormatELF());
GlobalVariable *GV; if (UseComdat) {
if (isa<InstrProfCoverInst>(Inc)) { StringRef GroupName = TT.isOSBinFormatCOFF() && DataReferencedByCode
auto *CounterTy = Type::getInt8Ty(Ctx); ? GV->getName()
auto *CounterArrTy = ArrayType::get(CounterTy, NumCounters); : VarName;
// TODO: `Constant::getAllOnesValue()` does not yet accept an array type. Comdat *C = M->getOrInsertComdat(GroupName);
std::vector<Constant *> InitialValues(NumCounters, if (!NeedComdat)
Constant::getAllOnesValue(CounterTy)); C->setSelectionKind(Comdat::NoDeduplicate);
GV = new GlobalVariable(*M, CounterArrTy, false, Linkage, GV->setComdat(C);
ConstantArray::get(CounterArrTy, InitialValues), // COFF doesn't allow the comdat group leader to have private linkage, so
Name); // upgrade private linkage to internal linkage to produce a symbol table
GV->setAlignment(Align(1)); // entry.
} else { if (TT.isOSBinFormatCOFF() && GV->hasPrivateLinkage())
auto *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters); GV->setLinkage(GlobalValue::InternalLinkage);
GV = new GlobalVariable(*M, CounterTy, false, Linkage,
Constant::getNullValue(CounterTy), Name);
GV->setAlignment(Align(8));
} }
return GV;
} }
GlobalVariable * GlobalVariable *InstrProfiling::setupProfileSection(InstrProfInstBase *Inc,
InstrProfiling::getOrCreateRegionCounters(InstrProfInstBase *Inc) { InstrProfSectKind IPSK) {
assert(IPSK == IPSK_cnts || IPSK == IPSK_bitmask);
GlobalVariable *NamePtr = Inc->getName(); GlobalVariable *NamePtr = Inc->getName();
auto &PD = ProfileDataMap[NamePtr];
if (PD.RegionCounters)
return PD.RegionCounters;
// Match the linkage and visibility of the name global. // Match the linkage and visibility of the name global.
Function *Fn = Inc->getParent()->getParent(); Function *Fn = Inc->getParent()->getParent();
GlobalValue::LinkageTypes Linkage = NamePtr->getLinkage(); GlobalValue::LinkageTypes Linkage = NamePtr->getLinkage();
GlobalValue::VisibilityTypes Visibility = NamePtr->getVisibility(); GlobalValue::VisibilityTypes Visibility = NamePtr->getVisibility();
// Use internal rather than private linkage so the counter variable shows up // Use internal rather than private linkage so the counter variable shows up
// in the symbol table when using debug info for correlation. // in the symbol table when using debug info for correlation.
if (DebugInfoCorrelate && TT.isOSBinFormatMachO() && if (DebugInfoCorrelate && TT.isOSBinFormatMachO() &&
Linkage == GlobalValue::PrivateLinkage) Linkage == GlobalValue::PrivateLinkage)
Linkage = GlobalValue::InternalLinkage; Linkage = GlobalValue::InternalLinkage;
// Due to the limitation of binder as of 2021/09/28, the duplicate weak // Due to the limitation of binder as of 2021/09/28, the duplicate weak
// symbols in the same csect won't be discarded. When there are duplicate weak // symbols in the same csect won't be discarded. When there are duplicate weak
// symbols, we can NOT guarantee that the relocations get resolved to the // symbols, we can NOT guarantee that the relocations get resolved to the
// intended weak symbol, so we can not ensure the correctness of the relative // intended weak symbol, so we can not ensure the correctness of the relative
// CounterPtr, so we have to use private linkage for counter and data symbols. // CounterPtr, so we have to use private linkage for counter and data symbols.
if (TT.isOSBinFormatXCOFF()) { if (TT.isOSBinFormatXCOFF()) {
Linkage = GlobalValue::PrivateLinkage; Linkage = GlobalValue::PrivateLinkage;
Show All 11 LinesGlobalVariable *InstrProfiling::setupProfileSection(InstrProfInstBase *Inc,
// in different comdats for COFF because the Visual C++ linker will report // in different comdats for COFF because the Visual C++ linker will report
// duplicate symbol errors if there are multiple external symbols with the // duplicate symbol errors if there are multiple external symbols with the
// same name marked IMAGE_COMDAT_SELECT_ASSOCIATIVE. // same name marked IMAGE_COMDAT_SELECT_ASSOCIATIVE.
// //
// For ELF, when not using COMDAT, put counters, data and values into a // For ELF, when not using COMDAT, put counters, data and values into a
// nodeduplicate COMDAT which is lowered to a zero-flag section group. This // nodeduplicate COMDAT which is lowered to a zero-flag section group. This
// allows -z start-stop-gc to discard the entire group when the function is // allows -z start-stop-gc to discard the entire group when the function is
// discarded. // discarded.
bool DataReferencedByCode = profDataReferencedByCode(*M);
bool NeedComdat = needsComdatForCounter(*Fn, *M);
bool Renamed; bool Renamed;
std::string CntsVarName = StringRef VarPrefix = (IPSK == IPSK_cnts) ? getInstrProfCountersVarPrefix()
getVarName(Inc, getInstrProfCountersVarPrefix(), Renamed); : getInstrProfBitmaskVarPrefix();
std::string DataVarName = std::string VarName = getVarName(Inc, VarPrefix, Renamed);
getVarName(Inc, getInstrProfDataVarPrefix(), Renamed);
auto MaybeSetComdat = [&](GlobalVariable *GV) { auto *Ptr = (IPSK == IPSK_cnts) ? createRegionCounters(Inc, VarName, Linkage)
bool UseComdat = (NeedComdat || TT.isOSBinFormatELF()); : createRegionBitmasks(Inc, VarName, Linkage);
if (UseComdat) { Ptr->setVisibility(Visibility);
StringRef GroupName = TT.isOSBinFormatCOFF() && DataReferencedByCode // Put the counters and bitmask in their own sections so linkers can
? GV->getName() // remove unneeded sections.
: CntsVarName; Ptr->setSection(getInstrProfSectionName(IPSK, TT.getObjectFormat()));
Comdat *C = M->getOrInsertComdat(GroupName); Ptr->setLinkage(Linkage);
if (!NeedComdat) maybeSetComdat(Ptr, Fn, VarName);
C->setSelectionKind(Comdat::NoDeduplicate); return Ptr;
GV->setComdat(C); }
// COFF doesn't allow the comdat group leader to have private linkage, so
// upgrade private linkage to internal linkage to produce a symbol table GlobalVariable *
// entry. InstrProfiling::createRegionBitmasks(InstrProfInstBase *Inc, StringRef Name,
if (TT.isOSBinFormatCOFF() && GV->hasPrivateLinkage()) GlobalValue::LinkageTypes Linkage) {
GV->setLinkage(GlobalValue::InternalLinkage); uint64_t NumBytes = Inc->getNumBitmaskBytes()->getZExtValue();
auto *BitmaskTy = ArrayType::get(Type::getInt8Ty(M->getContext()), NumBytes);
auto GV = new GlobalVariable(*M, BitmaskTy, false, Linkage,
Constant::getNullValue(BitmaskTy), Name);
GV->setAlignment(Align(1));
return GV;
} }
};
GlobalVariable *
InstrProfiling::getOrCreateRegionBitmasks(InstrProfInstBase *Inc) {
GlobalVariable *NamePtr = Inc->getName();
auto &PD = ProfileDataMap[NamePtr];
if (PD.RegionBitmasks)
return PD.RegionBitmasks;
auto *BitmaskPtr = setupProfileSection(Inc, IPSK_bitmask);
PD.RegionBitmasks = BitmaskPtr;
return PD.RegionBitmasks;
}
GlobalVariable *
InstrProfiling::createRegionCounters(InstrProfInstBase *Inc, StringRef Name,
GlobalValue::LinkageTypes Linkage) {
uint64_t NumCounters = Inc->getNumCounters()->getZExtValue(); uint64_t NumCounters = Inc->getNumCounters()->getZExtValue();
LLVMContext &Ctx = M->getContext(); auto &Ctx = M->getContext();
GlobalVariable *GV;
if (isa<InstrProfCoverInst>(Inc)) {
auto *CounterTy = Type::getInt8Ty(Ctx);
auto *CounterArrTy = ArrayType::get(CounterTy, NumCounters);
// TODO: `Constant::getAllOnesValue()` does not yet accept an array type.
std::vector<Constant *> InitialValues(NumCounters,
Constant::getAllOnesValue(CounterTy));
GV = new GlobalVariable(*M, CounterArrTy, false, Linkage,
ConstantArray::get(CounterArrTy, InitialValues),
Name);
GV->setAlignment(Align(1));
} else {
auto *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters);
GV = new GlobalVariable(*M, CounterTy, false, Linkage,
Constant::getNullValue(CounterTy), Name);
GV->setAlignment(Align(8));
}
return GV;
}
auto *CounterPtr = createRegionCounters(Inc, CntsVarName, Linkage); GlobalVariable *
CounterPtr->setVisibility(Visibility); InstrProfiling::getOrCreateRegionCounters(InstrProfInstBase *Inc) {
CounterPtr->setSection( GlobalVariable *NamePtr = Inc->getName();
getInstrProfSectionName(IPSK_cnts, TT.getObjectFormat())); auto &PD = ProfileDataMap[NamePtr];
CounterPtr->setLinkage(Linkage); if (PD.RegionCounters)
MaybeSetComdat(CounterPtr); return PD.RegionCounters;
auto *CounterPtr = setupProfileSection(Inc, IPSK_cnts);
PD.RegionCounters = CounterPtr; PD.RegionCounters = CounterPtr;
if (DebugInfoCorrelate) { if (DebugInfoCorrelate) {
LLVMContext &Ctx = M->getContext();
Function *Fn = Inc->getParent()->getParent();
if (auto *SP = Fn->getSubprogram()) { if (auto *SP = Fn->getSubprogram()) {
DIBuilder DB(*M, true, SP->getUnit()); DIBuilder DB(*M, true, SP->getUnit());
Metadata *FunctionNameAnnotation[] = { Metadata *FunctionNameAnnotation[] = {
MDString::get(Ctx, InstrProfCorrelator::FunctionNameAttributeName), MDString::get(Ctx, InstrProfCorrelator::FunctionNameAttributeName),
MDString::get(Ctx, getPGOFuncNameVarInitializer(NamePtr)), MDString::get(Ctx, getPGOFuncNameVarInitializer(NamePtr)),
}; };
Metadata *CFGHashAnnotation[] = { Metadata *CFGHashAnnotation[] = {
MDString::get(Ctx, InstrProfCorrelator::CFGHashAttributeName), MDString::get(Ctx, InstrProfCorrelator::CFGHashAttributeName),
Show All 18 Lines if (auto *SP = Fn->getSubprogram()) {
DB.finalize(); DB.finalize();
} else { } else {
std::string Msg = ("Missing debug info for function " + Fn->getName() + std::string Msg = ("Missing debug info for function " + Fn->getName() +
"; required for profile correlation.") "; required for profile correlation.")
.str(); .str();
Ctx.diagnose( Ctx.diagnose(
DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning)); DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning));
} }
// Mark the counter variable as used so that it isn't optimized out.
CompilerUsedVars.push_back(PD.RegionCounters);
}
return PD.RegionCounters;
}
void InstrProfiling::createDataVariable(InstrProfInstBase *Inc,
InstrProfInstBase *Params) {
if (DebugInfoCorrelate)
return;
GlobalVariable *NamePtr = Inc->getName();
auto &PD = ProfileDataMap[NamePtr];
LLVMContext &Ctx = M->getContext();
Function *Fn = Inc->getParent()->getParent();
GlobalValue::LinkageTypes Linkage = NamePtr->getLinkage();
GlobalValue::VisibilityTypes Visibility = NamePtr->getVisibility();
// Use internal rather than private linkage so the counter variable shows up
// in the symbol table when using debug info for correlation.
if (DebugInfoCorrelate && TT.isOSBinFormatMachO() &&
Linkage == GlobalValue::PrivateLinkage)
Linkage = GlobalValue::InternalLinkage;
// Due to the limitation of binder as of 2021/09/28, the duplicate weak
// symbols in the same csect won't be discarded. When there are duplicate weak
// symbols, we can NOT guarantee that the relocations get resolved to the
// intended weak symbol, so we can not ensure the correctness of the relative
// CounterPtr, so we have to use private linkage for counter and data symbols.
if (TT.isOSBinFormatXCOFF()) {
Linkage = GlobalValue::PrivateLinkage;
Visibility = GlobalValue::DefaultVisibility;
} }
bool DataReferencedByCode = profDataReferencedByCode(*M);
bool NeedComdat = needsComdatForCounter(*Fn, *M);
bool Renamed;
// The Data Variable section is anchored to profile counters.
std::string CntsVarName =
getVarName(Inc, getInstrProfCountersVarPrefix(), Renamed);
std::string DataVarName =
getVarName(Inc, getInstrProfDataVarPrefix(), Renamed);
auto *Int8PtrTy = Type::getInt8PtrTy(Ctx); auto *Int8PtrTy = Type::getInt8PtrTy(Ctx);
// Allocate statically the array of pointers to value profile nodes for // Allocate statically the array of pointers to value profile nodes for
// the current function. // the current function.
Constant *ValuesPtrExpr = ConstantPointerNull::get(Int8PtrTy); Constant *ValuesPtrExpr = ConstantPointerNull::get(Int8PtrTy);
uint64_t NS = 0; uint64_t NS = 0;
for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind) for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
NS += PD.NumValueSites[Kind]; NS += PD.NumValueSites[Kind];
if (NS > 0 && ValueProfileStaticAlloc && if (NS > 0 && ValueProfileStaticAlloc &&
!needsRuntimeRegistrationOfSectionRange(TT)) { !needsRuntimeRegistrationOfSectionRange(TT)) {
ArrayType *ValuesTy = ArrayType::get(Type::getInt64Ty(Ctx), NS); ArrayType *ValuesTy = ArrayType::get(Type::getInt64Ty(Ctx), NS);
auto *ValuesVar = new GlobalVariable( auto *ValuesVar = new GlobalVariable(
*M, ValuesTy, false, Linkage, Constant::getNullValue(ValuesTy), *M, ValuesTy, false, Linkage, Constant::getNullValue(ValuesTy),
getVarName(Inc, getInstrProfValuesVarPrefix(), Renamed)); getVarName(Inc, getInstrProfValuesVarPrefix(), Renamed));
ValuesVar->setVisibility(Visibility); ValuesVar->setVisibility(Visibility);
ValuesVar->setSection( ValuesVar->setSection(
getInstrProfSectionName(IPSK_vals, TT.getObjectFormat())); getInstrProfSectionName(IPSK_vals, TT.getObjectFormat()));
ValuesVar->setAlignment(Align(8)); ValuesVar->setAlignment(Align(8));
MaybeSetComdat(ValuesVar); maybeSetComdat(ValuesVar, Fn, CntsVarName);
ValuesPtrExpr = ValuesPtrExpr =
ConstantExpr::getBitCast(ValuesVar, Type::getInt8PtrTy(Ctx)); ConstantExpr::getBitCast(ValuesVar, Type::getInt8PtrTy(Ctx));
} }
if (DebugInfoCorrelate) { uint64_t NumCounters = Inc->getNumCounters()->getZExtValue();
// Mark the counter variable as used so that it isn't optimized out. auto *CounterPtr = PD.RegionCounters;
CompilerUsedVars.push_back(PD.RegionCounters);
return PD.RegionCounters; uint64_t NumBitmaskBytes = 0;
} if (Params != nullptr)
NumBitmaskBytes = Params->getNumBitmaskBytes()->getZExtValue();
// Create data variable. // Create data variable.
auto *IntPtrTy = M->getDataLayout().getIntPtrType(M->getContext()); auto *IntPtrTy = M->getDataLayout().getIntPtrType(M->getContext());
auto *Int16Ty = Type::getInt16Ty(Ctx); auto *Int16Ty = Type::getInt16Ty(Ctx);
auto *Int16ArrayTy = ArrayType::get(Int16Ty, IPVK_Last + 1); auto *Int16ArrayTy = ArrayType::get(Int16Ty, IPVK_Last + 1);
Type *DataTypes[] = { Type *DataTypes[] = {
#define INSTR_PROF_DATA(Type, LLVMType, Name, Init) LLVMType, #define INSTR_PROF_DATA(Type, LLVMType, Name, Init) LLVMType,
#include "llvm/ProfileData/InstrProfData.inc" #include "llvm/ProfileData/InstrProfData.inc"
Show All 28 Lines#include "llvm/ProfileData/InstrProfData.inc"
auto *Data = auto *Data =
new GlobalVariable(*M, DataTy, false, Linkage, nullptr, DataVarName); new GlobalVariable(*M, DataTy, false, Linkage, nullptr, DataVarName);
// Reference the counter variable with a label difference (link-time // Reference the counter variable with a label difference (link-time
// constant). // constant).
auto *RelativeCounterPtr = auto *RelativeCounterPtr =
ConstantExpr::getSub(ConstantExpr::getPtrToInt(CounterPtr, IntPtrTy), ConstantExpr::getSub(ConstantExpr::getPtrToInt(CounterPtr, IntPtrTy),
ConstantExpr::getPtrToInt(Data, IntPtrTy)); ConstantExpr::getPtrToInt(Data, IntPtrTy));
// Bitmasks are relative to the same data variable as profile counters.
GlobalVariable *BitmaskPtr = PD.RegionBitmasks;
Constant *RelativeBitmaskPtr = ConstantInt::get(IntPtrTy, 0);
if (BitmaskPtr != nullptr) {
RelativeBitmaskPtr =
ConstantExpr::getSub(ConstantExpr::getPtrToInt(BitmaskPtr, IntPtrTy),
ConstantExpr::getPtrToInt(Data, IntPtrTy));
}
Constant *DataVals[] = { Constant *DataVals[] = {
#define INSTR_PROF_DATA(Type, LLVMType, Name, Init) Init, #define INSTR_PROF_DATA(Type, LLVMType, Name, Init) Init,
#include "llvm/ProfileData/InstrProfData.inc" #include "llvm/ProfileData/InstrProfData.inc"
}; };
Data->setInitializer(ConstantStruct::get(DataTy, DataVals)); Data->setInitializer(ConstantStruct::get(DataTy, DataVals));
Data->setVisibility(Visibility); Data->setVisibility(Visibility);
Data->setSection(getInstrProfSectionName(IPSK_data, TT.getObjectFormat())); Data->setSection(getInstrProfSectionName(IPSK_data, TT.getObjectFormat()));
Data->setAlignment(Align(INSTR_PROF_DATA_ALIGNMENT)); Data->setAlignment(Align(INSTR_PROF_DATA_ALIGNMENT));
MaybeSetComdat(Data); maybeSetComdat(Data, Fn, CntsVarName);
PD.DataVar = Data; PD.DataVar = Data;
// Mark the data variable as used so that it isn't stripped out. // Mark the data variable as used so that it isn't stripped out.
CompilerUsedVars.push_back(Data); CompilerUsedVars.push_back(Data);
// Now that the linkage set by the FE has been passed to the data and counter // Now that the linkage set by the FE has been passed to the data and counter
// variables, reset Name variable's linkage and visibility to private so that // variables, reset Name variable's linkage and visibility to private so that
// it can be removed later by the compiler. // it can be removed later by the compiler.
NamePtr->setLinkage(GlobalValue::PrivateLinkage); NamePtr->setLinkage(GlobalValue::PrivateLinkage);
// Collect the referenced names to be used by emitNameData. // Collect the referenced names to be used by emitNameData.
ReferencedNames.push_back(NamePtr); ReferencedNames.push_back(NamePtr);
return PD.RegionCounters;
} }
void InstrProfiling::emitVNodes() { void InstrProfiling::emitVNodes() {
if (!ValueProfileStaticAlloc) if (!ValueProfileStaticAlloc)
return; return;
// For now only support this on platforms that do // For now only support this on platforms that do
// not require runtime registration to discover // not require runtime registration to discover
▲ Show 20 Lines • Show All 210 Lines • Show Last 20 Lines

llvm/test/Transforms/PGOProfile/comdat_internal.ll

; RUN: opt < %s -passes=pgo-instr-gen,instrprof -S | FileCheck %s ; RUN: opt < %s -passes=pgo-instr-gen,instrprof -S | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
$foo = comdat any $foo = comdat any
; CHECK: $foo = comdat any ; CHECK: $foo = comdat any
; CHECK: $__llvm_profile_raw_version = comdat any ; CHECK: $__llvm_profile_raw_version = comdat any
; CHECK: $__profc__stdin__foo.[[#FOO_HASH:]] = comdat any ; CHECK: $__profc__stdin__foo.[[#FOO_HASH:]] = comdat any
@bar = global ptr @foo, align 8 @bar = global ptr @foo, align 8
; CHECK: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat ; CHECK: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat
; CHECK-NOT: __profn__stdin__foo ; CHECK-NOT: __profn__stdin__foo
; CHECK: @__profc__stdin__foo.[[#FOO_HASH]] = private global [1 x i64] zeroinitializer, section "__llvm_prf_cnts", comdat, align 8 ; CHECK: @__profc__stdin__foo.[[#FOO_HASH]] = private global [1 x i64] zeroinitializer, section "__llvm_prf_cnts", comdat, align 8
; CHECK: @__profd__stdin__foo.[[#FOO_HASH]] = private global { i64, i64, i64, ptr, ptr, i32, [2 x i16] } { i64 -5640069336071256030, i64 [[#FOO_HASH]], i64 sub (i64 ptrtoint (ptr @__profc__stdin__foo.742261418966908927 to i64), i64 ptrtoint (ptr @__profd__stdin__foo.742261418966908927 to i64)), ptr null ; CHECK: @__profd__stdin__foo.[[#FOO_HASH]] = private global { i64, i64, i64, i64, ptr, ptr, i32, [2 x i16], i32 } { i64 -5640069336071256030, i64 [[#FOO_HASH]], i64 sub (i64 ptrtoint (ptr @__profc__stdin__foo.742261418966908927 to i64), i64 ptrtoint (ptr @__profd__stdin__foo.742261418966908927 to i64)), i64 0, ptr null
; CHECK-NOT: @foo ; CHECK-NOT: @foo
; CHECK-SAME: , ptr null, i32 1, [2 x i16] zeroinitializer }, section "__llvm_prf_data", comdat($__profc__stdin__foo.[[#FOO_HASH]]), align 8 ; CHECK-SAME: , ptr null, i32 1, [2 x i16] zeroinitializer, i32 0 }, section "__llvm_prf_data", comdat($__profc__stdin__foo.[[#FOO_HASH]]), align 8
; CHECK: @__llvm_prf_nm ; CHECK: @__llvm_prf_nm
; CHECK: @llvm.compiler.used ; CHECK: @llvm.compiler.used
define internal i32 @foo() comdat { define internal i32 @foo() comdat {
entry: entry:
ret i32 1 ret i32 1
} }

llvm/test/tools/llvm-cov/Inputs/binary-formats.canonical.json

CHECK: {"data": CHECK: {"data":
CHECK-SAME: [{ CHECK-SAME: [{
CHECK-SAME: "files":[ CHECK-SAME: "files":[
CHECK-SAME: {"branches":[], CHECK-SAME: {"branches":[],
CHECK-SAME: "expansions":[], CHECK-SAME: "expansions":[],
CHECK-SAME: "filename":"/tmp/binary-formats.c", CHECK-SAME: "filename":"/tmp/binary-formats.c",
CHECK-SAME: "mcdc_records":[],
CHECK-SAME: "segments": CHECK-SAME: "segments":
CHECK-SAME: 4,40,100,true,true,false CHECK-SAME: 4,40,100,true,true,false
CHECK-SAME: 4,42,0,false,false,false CHECK-SAME: 4,42,0,false,false,false
CHECK-SAME: "summary":{"branches":{"count":0,"covered":0,"notcovered":0,"percent":0}, CHECK-SAME: "summary":{"branches":{"count":0,"covered":0,"notcovered":0,"percent":0},
CHECK-SAME: "functions":{"count":1,"covered":1,"percent":100}, CHECK-SAME: "functions":{"count":1,"covered":1,"percent":100},
CHECK-SAME: "instantiations":{"count":1,"covered":1,"percent":100}, CHECK-SAME: "instantiations":{"count":1,"covered":1,"percent":100},
CHECK-SAME: "lines":{"count":1,"covered":1,"percent":100}, CHECK-SAME: "lines":{"count":1,"covered":1,"percent":100},
CHECK-SAME: "mcdc":{"count":0,"covered":0,"notcovered":0,"percent":0},
CHECK-SAME: "regions":{"count":1,"covered":1,"notcovered":0,"percent":100}}} CHECK-SAME: "regions":{"count":1,"covered":1,"notcovered":0,"percent":100}}}
CHECK-SAME: ], CHECK-SAME: ],
CHECK-SAME: "functions":[ CHECK-SAME: "functions":[
CHECK-SAME: {"branches":[], CHECK-SAME: {"branches":[],
CHECK-SAME: "count":100,"filenames":["/tmp/binary-formats.c"],"name":"main", CHECK-SAME: "count":100,"filenames":["/tmp/binary-formats.c"],
CHECK-SAME: "mcdc_records":[],"name":"main",
CHECK-SAME: "regions": CHECK-SAME: "regions":
CHECK-SAME: 4,40,4,42,100,0,0,0 CHECK-SAME: 4,40,4,42,100,0,0,0
CHECK-SAME: } CHECK-SAME: }
CHECK-SAME: ], CHECK-SAME: ],
CHECK-SAME: "totals": CHECK-SAME: "totals":
CHECK-SAME: {"branches":{"count":0,"covered":0,"notcovered":0,"percent":0}, CHECK-SAME: {"branches":{"count":0,"covered":0,"notcovered":0,"percent":0},
CHECK-SAME: "functions":{"count":1,"covered":1,"percent":100}, CHECK-SAME: "functions":{"count":1,"covered":1,"percent":100},
CHECK-SAME: "instantiations":{"count":1,"covered":1,"percent":100}, CHECK-SAME: "instantiations":{"count":1,"covered":1,"percent":100},
CHECK-SAME: "lines":{"count":1,"covered":1,"percent":100}, CHECK-SAME: "lines":{"count":1,"covered":1,"percent":100},
CHECk-SAME: "mcdc":{"count":0,"covered":0,"notcovered":0,"percent":0},
CHECK-SAME: "regions":{"count":1,"covered":1,"notcovered":0,"percent":100}}} CHECK-SAME: "regions":{"count":1,"covered":1,"notcovered":0,"percent":100}}}
CHECK-SAME: ], CHECK-SAME: ],
CHECK-SAME: "type":"llvm.coverage.json.export" CHECK-SAME: "type":"llvm.coverage.json.export"
CHECK-SAME: "version":"2.0.1" CHECK-SAME: "version":"2.0.1"

llvm/test/tools/llvm-cov/Inputs/mcdc-const-folding.cpp

  • This file was added.
#include <stdlib.h>
bool case0(bool a) {
return 0 && a;
}
bool case1(bool a) {
return a && 0;
}
bool case2(bool a) {
return 1 && a;
}
bool case3(bool a) {
return a && 1;
}
bool case4(bool a) {
return 1 || a;
}
bool case5(bool a) {
return a || 1;
}
bool case6(bool a) {
return 0 || a;
}
bool case7(bool a) {
return a || 0;
}
bool case8(bool a, bool b) {
return 0 && a && b;
}
bool case9(bool a, bool b) {
return a && 0 && b;
}
bool casea(bool a, bool b) {
return 1 && a && b;
}
bool caseb(bool a, bool b) {
return a && 1 && b;
}
bool casec(bool a, bool b) {
return 1 || a || b;
}
bool cased(bool a, bool b) {
return a || 1 || b;
}
bool casee(bool a, bool b) {
return 0 || a || b;
}
bool casef(bool a, bool b) {
return a || 0 || b;
}
bool caseg(bool a, bool b) {
return b && a && 0;
}
bool caseh(bool a, bool b) {
return b && 0 && a;
}
bool casei(bool a, bool b) {
return b && a && 1;
}
bool casej(bool a, bool b) {
return b && 1 && a;
}
bool casek(bool a, bool b) {
return b || a || 1;
}
bool casel(bool a, bool b) {
return b || 1 || a;
}
bool casem(bool a, bool b) {
return b || a || 0;
}
bool casen(bool a, bool b) {
return b || 0 || a;
}
extern "C" {
extern void __llvm_profile_write_file(void);
}
int main(int argc, char *argv[])
{
bool a = atoi(argv[1]);
bool b = atoi(argv[2]);
volatile bool c;
c = case0(a);
c = case1(a);
c = case2(a);
c = case3(a);
c = case4(a);
c = case5(a);
c = case6(a);
c = case7(a);
c = case8(a, b);
c = case9(a, b);
c = casea(a, b);
c = caseb(a, b);
c = casec(a, b);
c = cased(a, b);
c = casee(a, b);
c = casef(a, b);
c = caseg(a, b);
c = caseh(a, b);
c = casei(a, b);
c = casej(a, b);
c = casek(a, b);
c = casel(a, b);
c = casem(a, b);
c = casen(a, b);
__llvm_profile_write_file();
return 0;
}

llvm/test/tools/llvm-cov/Inputs/mcdc-const-folding.o32l

  • This binary file was added.

llvm/test/tools/llvm-cov/Inputs/mcdc-const-folding.proftext

  • This file was added.
_Z5case8bb
# Func Hash:
99214
# Num Counters:
5
# Counter Values:
4
0
0
0
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
1
_Z5case5b
# Func Hash:
1551
# Num Counters:
3
# Counter Values:
4
1
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
6
_Z5caseabb
# Func Hash:
99214
# Num Counters:
5
# Counter Values:
4
3
2
4
3
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
a2
_Z5case6b
# Func Hash:
1551
# Num Counters:
3
# Counter Values:
4
4
1
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
5
_Z5casegbb
# Func Hash:
99214
# Num Counters:
5
# Counter Values:
4
2
0
3
2
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
23
_Z5case1b
# Func Hash:
1550
# Num Counters:
3
# Counter Values:
4
3
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
3
_Z5case7b
# Func Hash:
1551
# Num Counters:
3
# Counter Values:
4
1
1
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
3
_Z5casedbb
# Func Hash:
99279
# Num Counters:
5
# Counter Values:
4
0
0
1
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
12
_Z5casekbb
# Func Hash:
99279
# Num Counters:
5
# Counter Values:
4
0
0
1
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
12
_Z5casehbb
# Func Hash:
99214
# Num Counters:
5
# Counter Values:
4
0
0
3
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
3
_Z5case4b
# Func Hash:
1551
# Num Counters:
3
# Counter Values:
4
0
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
2
_Z5caseibb
# Func Hash:
99214
# Num Counters:
5
# Counter Values:
4
2
2
3
2
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
83
_Z5case2b
# Func Hash:
1550
# Num Counters:
3
# Counter Values:
4
4
3
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
a
_Z5casefbb
# Func Hash:
99279
# Num Counters:
5
# Counter Values:
4
1
0
1
1
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
6
_Z5caselbb
# Func Hash:
99279
# Num Counters:
5
# Counter Values:
4
0
0
1
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
12
_Z5casenbb
# Func Hash:
99279
# Num Counters:
5
# Counter Values:
4
1
0
1
1
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
6
_Z5case9bb
# Func Hash:
99214
# Num Counters:
5
# Counter Values:
4
0
0
3
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
3
_Z5casecbb
# Func Hash:
99279
# Num Counters:
5
# Counter Values:
4
0
0
0
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
2
_Z5casebbb
# Func Hash:
99214
# Num Counters:
5
# Counter Values:
4
3
2
3
3
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
a1
_Z5case0b
# Func Hash:
1550
# Num Counters:
3
# Counter Values:
4
0
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
1
_Z5casejbb
# Func Hash:
99214
# Num Counters:
5
# Counter Values:
4
3
2
3
3
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
a1
_Z5caseebb
# Func Hash:
99279
# Num Counters:
5
# Counter Values:
4
1
0
4
1
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
14
main
# Func Hash:
24
# Num Counters:
1
# Counter Values:
4
_Z5case3b
# Func Hash:
1550
# Num Counters:
3
# Counter Values:
4
3
3
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
9
_Z5casembb
# Func Hash:
99279
# Num Counters:
5
# Counter Values:
4
0
0
1
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
12

llvm/test/tools/llvm-cov/Inputs/mcdc-const.cpp

  • This file was added.
#include <stdio.h>
extern "C" {
extern void __llvm_profile_write_file(void);
}
extern int foo();
void test(bool a, bool b, bool c, bool d) {
if ((a && 1) || (0 && d) || 0)
printf("test1 decision true\n");
}
int main()
{
test(true,false,true,false);
test(true,false,true,true);
test(true,true,false,false);
test(false,true,true,false);
test(true,false,false,false);
__llvm_profile_write_file();
return 0;
}

llvm/test/tools/llvm-cov/Inputs/mcdc-const.o32l

  • This binary file was added.

llvm/test/tools/llvm-cov/Inputs/mcdc-const.proftext

  • This file was added.
main
# Func Hash:
24
# Num Counters:
1
# Counter Values:
1
_Z4testbbbb
# Func Hash:
703556281489
# Num Counters:
9
# Counter Values:
5
4
1
1
1
4
4
0
0
# Num Bitmask Bytes:
$4
# Bitmask Byte Values:
1
2
0
0

llvm/test/tools/llvm-cov/Inputs/mcdc-general-none.proftext

  • This file was added.
main
# Func Hash:
24
# Num Counters:
1
# Counter Values:
1
_Z4testbbbb
# Func Hash:
9819241276358969079
# Num Counters:
19
# Counter Values:
7
3
5
5
2
3
1
2
3
2
1
1
1
1
2
4
2
2
1
# Num Bitmask Bytes:
$6
# Bitmask Byte Values:
0
0
0
0
0
0

llvm/test/tools/llvm-cov/Inputs/mcdc-general.cpp

  • This file was added.
#include <stdio.h>
extern "C" {
extern void __llvm_profile_write_file(void);
}
extern int foo();
void test(bool a, bool b, bool c, bool d) {
if ((a && b) || (c && d))
printf("test1 decision true\n");
if (b && c) if (a && d)
printf("test2 decision true\n");
if ((c && d) &&
(a && b))
printf("test3 decision true\n");
}
int main()
{
test(false,false,false,false);
test(true,false,true,false);
test(true,false,true,true);
test(true,true,false,false);
test(true,false,false,false);
test(true,true,true,true);
test(false,true,true,false);
__llvm_profile_write_file();
return 0;
}

llvm/test/tools/llvm-cov/Inputs/mcdc-general.o32l

  • This binary file was added.

llvm/test/tools/llvm-cov/Inputs/mcdc-general.proftext

  • This file was added.
main
# Func Hash:
24
# Num Counters:
1
# Counter Values:
1
_Z4testbbbb
# Func Hash:
9819241276358969079
# Num Counters:
19
# Counter Values:
7
3
5
5
2
3
1
2
3
2
1
1
1
1
2
4
2
2
1
# Num Bitmask Bytes:
$6
# Bitmask Byte Values:
2f
8
b
9
83
80

llvm/test/tools/llvm-cov/mcdc-const.test

  • This file was added.
// Test visualization of MC/DC constructs for constant-folded condition masking.
// RUN: llvm-profdata merge %S/Inputs/mcdc-const.proftext -o %t.profdata
// RUN: llvm-cov show --show-branches=count --show-mcdc %S/Inputs/mcdc-const.o32l -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-const.cpp | FileCheck %s -check-prefix=CHECKGENERALCASE
// CHECKGENERALCASE: ------------------
// CHECKGENERALCASE-NEXT: | Branch (12:8): [True: 4, False: 1]
// CHECKGENERALCASE-NEXT: | Branch (12:13): [Folded - Ignored]
// CHECKGENERALCASE-NEXT: | Branch (12:20): [Folded - Ignored]
// CHECKGENERALCASE-NEXT: | Branch (12:25): [True: 0, False: 0]
// CHECKGENERALCASE-NEXT: | Branch (12:31): [Folded - Ignored]
// CHECKGENERALCASE-NEXT: ------------------
// CHECKGENERALCASE-NEXT: |---> MC/DC Decision Region (12:7) to (12:32)
// CHECKGENERALCASE-NEXT: |
// CHECKGENERALCASE-NEXT: | Number of Conditions: 5
// CHECKGENERALCASE-NEXT: | Condition C1 --> (12:8)
// CHECKGENERALCASE-NEXT: | Condition C2 --> (12:13)
// CHECKGENERALCASE-NEXT: | Condition C3 --> (12:20)
// CHECKGENERALCASE-NEXT: | Condition C4 --> (12:25)
// CHECKGENERALCASE-NEXT: | Condition C5 --> (12:31)
// CHECKGENERALCASE-NEXT: |
// CHECKGENERALCASE-NEXT: | Executed MC/DC Test Vectors:
// CHECKGENERALCASE-NEXT: |
// CHECKGENERALCASE-NEXT: | C1, C2, C3, C4, C5 Result
// CHECKGENERALCASE-NEXT: | 1 { F, C, C, -, C = F }
// CHECKGENERALCASE-NEXT: | 2 { T, C, C, -, C = T }
// CHECKGENERALCASE-NEXT: |
// CHECKGENERALCASE-NEXT: | C1-Pair: covered: (1,2)
// CHECKGENERALCASE-NEXT: | C2-Pair: constant folded
// CHECKGENERALCASE-NEXT: | C3-Pair: constant folded
// CHECKGENERALCASE-NEXT: | C4-Pair: not covered
// CHECKGENERALCASE-NEXT: | C5-Pair: constant folded
// CHECKGENERALCASE-NEXT: | MC/DC Coverage for Decision: 50.00%
// CHECKGENERALCASE-NEXT: |
// CHECKGENERALCASE-NEXT: ------------------
// RUN: llvm-profdata merge %S/Inputs/mcdc-const-folding.proftext -o %t.profdata
// RUN: llvm-cov show --show-mcdc %S/Inputs/mcdc-const-folding.o32l -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-const-folding.cpp | FileCheck %s -check-prefix=CHECKFULLCASE
// RUN: llvm-cov report --show-mcdc-summary %S/Inputs/mcdc-const-folding.o32l -instr-profile %t.profdata -show-functions -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-const-folding.cpp | FileCheck %s -check-prefix=REPORT
// CHECKFULLCASE: | 1 { C, - = F }
// CHECKFULLCASE: | C1-Pair: constant folded
// CHECKFULLCASE: | C2-Pair: not covered
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { F, C = F }
// CHECKFULLCASE: | 2 { T, C = F }
// CHECKFULLCASE: | C1-Pair: not covered
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { C, F = F }
// CHECKFULLCASE: | 2 { C, T = T }
// CHECKFULLCASE: | C1-Pair: constant folded
// CHECKFULLCASE: | C2-Pair: covered: (1,2)
// CHECKFULLCASE: | MC/DC Coverage for Decision: 100.00%
// CHECKFULLCASE: | 1 { F, C = F }
// CHECKFULLCASE: | 2 { T, C = T }
// CHECKFULLCASE: | C1-Pair: covered: (1,2)
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | MC/DC Coverage for Decision: 100.00%
// CHECKFULLCASE: | 1 { C, - = T }
// CHECKFULLCASE: | C1-Pair: constant folded
// CHECKFULLCASE: | C2-Pair: not covered
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { T, C = T }
// CHECKFULLCASE: | 2 { F, C = T }
// CHECKFULLCASE: | C1-Pair: not covered
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { C, F = F }
// CHECKFULLCASE: | 2 { C, T = T }
// CHECKFULLCASE: | C1-Pair: constant folded
// CHECKFULLCASE: | C2-Pair: covered: (1,2)
// CHECKFULLCASE: | MC/DC Coverage for Decision: 100.00%
// CHECKFULLCASE: | 1 { F, C = F }
// CHECKFULLCASE: | 2 { T, C = T }
// CHECKFULLCASE: | C1-Pair: covered: (1,2)
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | MC/DC Coverage for Decision: 100.00%
// CHECKFULLCASE: | 1 { C, -, - = F }
// CHECKFULLCASE: | C1-Pair: constant folded
// CHECKFULLCASE: | C2-Pair: not covered
// CHECKFULLCASE: | C3-Pair: not covered
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { F, C, - = F }
// CHECKFULLCASE: | 2 { T, C, - = F }
// CHECKFULLCASE: | C1-Pair: not covered
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | C3-Pair: not covered
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { C, F, - = F }
// CHECKFULLCASE: | 2 { C, T, F = F }
// CHECKFULLCASE: | 3 { C, T, T = T }
// CHECKFULLCASE: | C1-Pair: constant folded
// CHECKFULLCASE: | C2-Pair: covered: (1,3)
// CHECKFULLCASE: | C3-Pair: covered: (2,3)
// CHECKFULLCASE: | MC/DC Coverage for Decision: 100.00%
// CHECKFULLCASE: | 1 { F, C, - = F }
// CHECKFULLCASE: | 2 { T, C, F = F }
// CHECKFULLCASE: | 3 { T, C, T = T }
// CHECKFULLCASE: | C1-Pair: covered: (1,3)
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | C3-Pair: covered: (2,3)
// CHECKFULLCASE: | MC/DC Coverage for Decision: 100.00%
// CHECKFULLCASE: | 1 { C, -, - = T }
// CHECKFULLCASE: | C1-Pair: constant folded
// CHECKFULLCASE: | C2-Pair: not covered
// CHECKFULLCASE: | C3-Pair: not covered
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { T, C, - = T }
// CHECKFULLCASE: | 2 { F, C, - = T }
// CHECKFULLCASE: | C1-Pair: not covered
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | C3-Pair: not covered
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { C, F, T = T }
// CHECKFULLCASE: | 2 { C, T, - = T }
// CHECKFULLCASE: | C1-Pair: constant folded
// CHECKFULLCASE: | C2-Pair: not covered
// CHECKFULLCASE: | C3-Pair: not covered
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { T, C, - = T }
// CHECKFULLCASE: | 2 { F, C, T = T }
// CHECKFULLCASE: | C1-Pair: not covered
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | C3-Pair: not covered
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { F, -, C = F }
// CHECKFULLCASE: | 2 { T, F, C = F }
// CHECKFULLCASE: | 3 { T, T, C = F }
// CHECKFULLCASE: | C1-Pair: not covered
// CHECKFULLCASE: | C2-Pair: not covered
// CHECKFULLCASE: | C3-Pair: constant folded
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { F, C, - = F }
// CHECKFULLCASE: | 2 { T, C, - = F }
// CHECKFULLCASE: | C1-Pair: not covered
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | C3-Pair: not covered
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { F, -, C = F }
// CHECKFULLCASE: | 2 { T, F, C = F }
// CHECKFULLCASE: | 3 { T, T, C = T }
// CHECKFULLCASE: | C1-Pair: covered: (1,3)
// CHECKFULLCASE: | C2-Pair: covered: (2,3)
// CHECKFULLCASE: | C3-Pair: constant folded
// CHECKFULLCASE: | MC/DC Coverage for Decision: 100.00%
// CHECKFULLCASE: | 1 { F, C, - = F }
// CHECKFULLCASE: | 2 { T, C, F = F }
// CHECKFULLCASE: | 3 { T, C, T = T }
// CHECKFULLCASE: | C1-Pair: covered: (1,3)
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | C3-Pair: covered: (2,3)
// CHECKFULLCASE: | MC/DC Coverage for Decision: 100.00%
// CHECKFULLCASE: | 1 { T, -, C = T }
// CHECKFULLCASE: | 2 { F, T, C = T }
// CHECKFULLCASE: | C1-Pair: not covered
// CHECKFULLCASE: | C2-Pair: not covered
// CHECKFULLCASE: | C3-Pair: constant folded
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { T, C, - = T }
// CHECKFULLCASE: | 2 { F, C, - = T }
// CHECKFULLCASE: | C1-Pair: not covered
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | C3-Pair: not covered
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { T, -, C = T }
// CHECKFULLCASE: | 2 { F, T, C = T }
// CHECKFULLCASE: | C1-Pair: not covered
// CHECKFULLCASE: | C2-Pair: not covered
// CHECKFULLCASE: | C3-Pair: constant folded
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// CHECKFULLCASE: | 1 { T, C, - = T }
// CHECKFULLCASE: | 2 { F, C, T = T }
// CHECKFULLCASE: | C1-Pair: not covered
// CHECKFULLCASE: | C2-Pair: constant folded
// CHECKFULLCASE: | C3-Pair: not covered
// CHECKFULLCASE: | MC/DC Coverage for Decision: 0.00%
// REPORT: _Z5case0b {{.*}} 1 1 0.00%
// REPORT: _Z5case1b {{.*}} 1 1 0.00%
// REPORT: _Z5case2b {{.*}} 1 0 100.00%
// REPORT: _Z5case3b {{.*}} 1 0 100.00%
// REPORT: _Z5case4b {{.*}} 1 1 0.00%
// REPORT: _Z5case5b {{.*}} 1 1 0.00%
// REPORT: _Z5case6b {{.*}} 1 0 100.00%
// REPORT: _Z5case7b {{.*}} 1 0 100.00%
// REPORT: _Z5case8bb {{.*}} 2 2 0.00%
// REPORT: _Z5case9bb {{.*}} 2 2 0.00%
// REPORT: _Z5caseabb {{.*}} 2 0 100.00%
// REPORT: _Z5casebbb {{.*}} 2 0 100.00%
// REPORT: _Z5casecbb {{.*}} 2 2 0.00%
// REPORT: _Z5casedbb {{.*}} 2 2 0.00%
// REPORT: _Z5caseebb {{.*}} 2 2 0.00%
// REPORT: _Z5casefbb {{.*}} 2 2 0.00%
// REPORT: _Z5casegbb {{.*}} 2 2 0.00%
// REPORT: _Z5casehbb {{.*}} 2 2 0.00%
// REPORT: _Z5caseibb {{.*}} 2 0 100.00%
// REPORT: _Z5casejbb {{.*}} 2 0 100.00%
// REPORT: _Z5casekbb {{.*}} 2 2 0.00%
// REPORT: _Z5caselbb {{.*}} 2 2 0.00%
// REPORT: _Z5casembb {{.*}} 2 2 0.00%
// REPORT: _Z5casenbb {{.*}} 2 2 0.00%
// REPORT: TOTAL {{.*}} 40 28 30.00%

llvm/test/tools/llvm-cov/mcdc-export-json.test

  • This file was added.
// RUN: llvm-profdata merge %S/Inputs/mcdc-general.proftext -o %t.profdata
// RUN: llvm-cov export --format=text %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata | FileCheck %s
// CHECK: 12,7,12,27,0,5,[true,true,true,true]
// CHECK: 15,7,15,13,0,5,[true,true]
// CHECK: 15,19,15,25,0,5,[true,false]
// CHECK: 18,7,19,15,0,5,[true,true,false,true]
// CHECK: "mcdc":{"count":12,"covered":10,"notcovered":2,"percent":83.333333333333343}

llvm/test/tools/llvm-cov/mcdc-general-none.test

  • This file was added.
// Test visualization of general MC/DC constructs with 0 executed test vectors.
// RUN: llvm-profdata merge %S/Inputs/mcdc-general-none.proftext -o %t.profdata
// RUN: llvm-cov show --show-mcdc %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s
// RUN: llvm-cov report --show-mcdc-summary %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -show-functions -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=REPORT
// CHECK: test(bool
// CHECK: ------------------
// CHECK-NEXT: |---> MC/DC Decision Region (12:7) to (12:27)
// CHECK-NEXT: |
// CHECK-NEXT: | Number of Conditions: 4
// CHECK-NEXT: | Condition C1 --> (12:8)
// CHECK-NEXT: | Condition C2 --> (12:13)
// CHECK-NEXT: | Condition C3 --> (12:20)
// CHECK-NEXT: | Condition C4 --> (12:25)
// CHECK-NEXT: |
// CHECK-NEXT: | Executed MC/DC Test Vectors:
// CHECK-NEXT: |
// CHECK-NEXT: | None.
// CHECK-NEXT: |
// CHECK-NEXT: | C1-Pair: not covered
// CHECK-NEXT: | C2-Pair: not covered
// CHECK-NEXT: | C3-Pair: not covered
// CHECK-NEXT: | C4-Pair: not covered
// CHECK-NEXT: | MC/DC Coverage for Decision: 0.00%
// CHECK-NEXT: |
// CHECK-NEXT: ------------------
// Turn off MC/DC visualization.
// RUN: llvm-cov show %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=NOMCDC
// NOMCDC-NOT: MC/DC Decision Region
// REPORT: Name Regions Miss Cover Lines Miss Cover Branches Miss Cover MC/DC Conditions Miss Cover
// REPORT-NEXT: -------------------------------------------------------------------------------------------------------------------------------------------
// REPORT-NEXT: _Z4testbbbb 25 0 100.00% 9 0 100.00% 24 2 91.67% 12 12 0.00%
// REPORT-NEXT: main 1 0 100.00% 11 0 100.00% 0 0 0.00% 0 0 0.00%
// REPORT-NEXT: ---
// REPORT-NEXT: TOTAL 26 0 100.00% 20 0 100.00% 24 2 91.67% 12 12 0.00%
// Turn off MC/DC summary.
// RUN: llvm-cov report %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -show-functions -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=REPORT_NOMCDC
// REPORT_NOMCDC-NOT: TOTAL{{.*}}12 12 0.00%
// Test file-level report.
// RUN: llvm-cov report --show-mcdc-summary %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=FILEREPORT
// FILEREPORT: TOTAL{{.*}}12 12 0.00%
// Test html output.
// RUN: llvm-cov show --show-mcdc-summary --show-mcdc %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp -format html -o %t.html.dir
// RUN: FileCheck -check-prefix=HTML -input-file=%t.html.dir/coverage/tmp/mcdc-general.cpp.html %s
// HTML-COUNT-4: MC/DC Decision Region (<span class='line-number'><a name='L{{[0-9]+}}' href='#L{{[0-9]+}}'><span>
// RUN: FileCheck -check-prefix HTML-INDEX -input-file %t.html.dir/index.html %s
// HTML-INDEX-LABEL: <table>
// HTML-INDEX: <td class='column-entry-bold'>Filename</td>
// HTML-INDEX: <td class='column-entry-bold'>Function Coverage</td>
// HTML-INDEX: <td class='column-entry-bold'>Line Coverage</td>
// HTML-INDEX: <td class='column-entry-bold'>Region Coverage</td>
// HTML-INDEX: <td class='column-entry-bold'>Branch Coverage</td>
// HTML-INDEX: <td class='column-entry-bold'>MC/DC</td>
// HTML-INDEX: <a href='coverage{{.*}}mcdc-general.cpp.html'{{.*}}mcdc-general.cpp</a>
// HTML-INDEX: <td class='column-entry-green'>
// HTML-INDEX: 100.00% (2/2)
// HTML-INDEX: 100.00% (20/20)
// HTML-INDEX: 100.00% (26/26)
// HTML-INDEX: 91.67% (22/24)
// HTML-INDEX: 0.00% (0/12)
// HTML-INDEX: Totals

llvm/test/tools/llvm-cov/mcdc-general.test

  • This file was added.
// Test visualization of general MC/DC constructs.
// RUN: llvm-profdata merge %S/Inputs/mcdc-general.proftext -o %t.profdata
// RUN: llvm-cov show --show-mcdc %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s
// RUN: llvm-cov report --show-mcdc-summary %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -show-functions -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=REPORT
// CHECK: test(bool
// CHECK: ------------------
// CHECK-NEXT: |---> MC/DC Decision Region (12:7) to (12:27)
// CHECK-NEXT: |
// CHECK-NEXT: | Number of Conditions: 4
// CHECK-NEXT: | Condition C1 --> (12:8)
// CHECK-NEXT: | Condition C2 --> (12:13)
// CHECK-NEXT: | Condition C3 --> (12:20)
// CHECK-NEXT: | Condition C4 --> (12:25)
// CHECK-NEXT: |
// CHECK-NEXT: | Executed MC/DC Test Vectors:
// CHECK-NEXT: |
// CHECK-NEXT: | C1, C2, C3, C4 Result
// CHECK-NEXT: | 1 { F, -, F, - = F }
// CHECK-NEXT: | 2 { T, F, F, - = F }
// CHECK-NEXT: | 3 { F, -, T, F = F }
// CHECK-NEXT: | 4 { T, F, T, F = F }
// CHECK-NEXT: | 5 { T, T, -, - = T }
// CHECK-NEXT: | 6 { T, F, T, T = T }
// CHECK-NEXT: |
// CHECK-NEXT: | C1-Pair: covered: (1,5)
// CHECK-NEXT: | C2-Pair: covered: (2,5)
// CHECK-NEXT: | C3-Pair: covered: (2,6)
// CHECK-NEXT: | C4-Pair: covered: (4,6)
// CHECK-NEXT: | MC/DC Coverage for Decision: 100.00%
// CHECK-NEXT: |
// CHECK-NEXT: ------------------
// CHECK: ------------------
// CHECK-NEXT: |---> MC/DC Decision Region (15:7) to (15:13)
// CHECK-NEXT: |
// CHECK-NEXT: | Number of Conditions: 2
// CHECK-NEXT: | Condition C1 --> (15:7)
// CHECK-NEXT: | Condition C2 --> (15:12)
// CHECK-NEXT: |
// CHECK-NEXT: | Executed MC/DC Test Vectors:
// CHECK-NEXT: |
// CHECK-NEXT: | C1, C2 Result
// CHECK-NEXT: | 1 { F, - = F }
// CHECK-NEXT: | 2 { T, F = F }
// CHECK-NEXT: | 3 { T, T = T }
// CHECK-NEXT: |
// CHECK-NEXT: | C1-Pair: covered: (1,3)
// CHECK-NEXT: | C2-Pair: covered: (2,3)
// CHECK-NEXT: | MC/DC Coverage for Decision: 100.00%
// CHECK-NEXT: |
// CHECK-NEXT: |---> MC/DC Decision Region (15:19) to (15:25)
// CHECK-NEXT: |
// CHECK-NEXT: | Number of Conditions: 2
// CHECK-NEXT: | Condition C1 --> (15:19)
// CHECK-NEXT: | Condition C2 --> (15:24)
// CHECK-NEXT: |
// CHECK-NEXT: | Executed MC/DC Test Vectors:
// CHECK-NEXT: |
// CHECK-NEXT: | C1, C2 Result
// CHECK-NEXT: | 1 { F, - = F }
// CHECK-NEXT: | 2 { T, T = T }
// CHECK-NEXT: |
// CHECK-NEXT: | C1-Pair: covered: (1,2)
// CHECK-NEXT: | C2-Pair: not covered
// CHECK-NEXT: | MC/DC Coverage for Decision: 50.00%
// CHECK-NEXT: |
// CHECK-NEXT: ------------------
// CHECK: ------------------
// CHECK-NEXT: |---> MC/DC Decision Region (18:7) to (19:15)
// CHECK-NEXT: |
// CHECK-NEXT: | Number of Conditions: 4
// CHECK-NEXT: | Condition C1 --> (18:8)
// CHECK-NEXT: | Condition C2 --> (18:13)
// CHECK-NEXT: | Condition C3 --> (19:8)
// CHECK-NEXT: | Condition C4 --> (19:13)
// CHECK-NEXT: |
// CHECK-NEXT: | Executed MC/DC Test Vectors:
// CHECK-NEXT: |
// CHECK-NEXT: | C1, C2, C3, C4 Result
// CHECK-NEXT: | 1 { F, -, -, - = F }
// CHECK-NEXT: | 2 { T, F, -, - = F }
// CHECK-NEXT: | 3 { T, T, T, F = F }
// CHECK-NEXT: | 4 { T, T, T, T = T }
// CHECK-NEXT: |
// CHECK-NEXT: | C1-Pair: covered: (1,4)
// CHECK-NEXT: | C2-Pair: covered: (2,4)
// CHECK-NEXT: | C3-Pair: not covered
// CHECK-NEXT: | C4-Pair: covered: (3,4)
// CHECK-NEXT: | MC/DC Coverage for Decision: 75.00%
// CHECK-NEXT: |
// CHECK-NEXT: ------------------
// Turn off MC/DC visualization.
// RUN: llvm-cov show %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=NOMCDC
// NOMCDC-NOT: MC/DC Decision Region
// REPORT: Name Regions Miss Cover Lines Miss Cover Branches Miss Cover MC/DC Conditions Miss Cover
// REPORT-NEXT: -------------------------------------------------------------------------------------------------------------------------------------------
// REPORT-NEXT: _Z4testbbbb 25 0 100.00% 9 0 100.00% 24 2 91.67% 12 2 83.33%
// REPORT-NEXT: main 1 0 100.00% 11 0 100.00% 0 0 0.00% 0 0 0.00%
// REPORT-NEXT: ---
// REPORT-NEXT: TOTAL 26 0 100.00% 20 0 100.00% 24 2 91.67% 12 2 83.33%
// Turn off MC/DC summary.
// RUN: llvm-cov report %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -show-functions -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=REPORT_NOMCDC
// REPORT_NOMCDC-NOT: TOTAL{{.*}}12 2 83.33%
// Test file-level report.
// RUN: llvm-cov report --show-mcdc-summary %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=FILEREPORT
// FILEREPORT: TOTAL{{.*}}12 2 83.33%
// Test html output.
// RUN: llvm-cov show --show-mcdc-summary --show-mcdc %S/Inputs/mcdc-general.o32l -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp -format html -o %t.html.dir
// RUN: FileCheck -check-prefix=HTML -input-file=%t.html.dir/coverage/tmp/mcdc-general.cpp.html %s
// HTML-COUNT-4: MC/DC Decision Region (<span class='line-number'><a name='L{{[0-9]+}}' href='#L{{[0-9]+}}'><span>
// RUN: FileCheck -check-prefix HTML-INDEX -input-file %t.html.dir/index.html %s
// HTML-INDEX-LABEL: <table>
// HTML-INDEX: <td class='column-entry-bold'>Filename</td>
// HTML-INDEX: <td class='column-entry-bold'>Function Coverage</td>
// HTML-INDEX: <td class='column-entry-bold'>Line Coverage</td>
// HTML-INDEX: <td class='column-entry-bold'>Region Coverage</td>
// HTML-INDEX: <td class='column-entry-bold'>Branch Coverage</td>
// HTML-INDEX: <td class='column-entry-bold'>MC/DC</td>
// HTML-INDEX: <a href='coverage{{.*}}mcdc-general.cpp.html'{{.*}}mcdc-general.cpp</a>
// HTML-INDEX: <td class='column-entry-green'>
// HTML-INDEX: 100.00% (2/2)
// HTML-INDEX: 100.00% (20/20)
// HTML-INDEX: 100.00% (26/26)
// HTML-INDEX: 91.67% (22/24)
// HTML-INDEX: 83.33% (10/12)
// HTML-INDEX: Totals

llvm/test/tools/llvm-profdata/Inputs/basic.profraw

  • This is a binary file.

llvm/test/tools/llvm-profdata/Inputs/c-general.profraw

  • This is a binary file.

llvm/test/tools/llvm-profdata/Inputs/compressed.profraw

  • This is a binary file.

llvm/test/tools/llvm-profdata/Inputs/mcdc-1.proftext

  • This file was added.
main
# Func Hash:
702755447896
# Num Counters:
4
# Counter Values:
1
0
1
0
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
2

llvm/test/tools/llvm-profdata/Inputs/mcdc-2.proftext

  • This file was added.
main
# Func Hash:
702755447896
# Num Counters:
4
# Counter Values:
1
1
1
1
# Num Bitmask Bytes:
$1
# Bitmask Byte Values:
8
test3
# Func Hash:
15288018065
# Num Counters:
6
# Counter Values:
4
2
1
0
0
2
# Num Bitmask Bytes:
$2
# Bitmask Byte Values:
29
0

llvm/test/tools/llvm-profdata/Inputs/mcdc-3.proftext

  • This file was added.
test3
# Func Hash:
15288018065
# Num Counters:
6
# Counter Values:
4
2
1
0
0
2
# Num Bitmask Bytes:
$8
# Bitmask Byte Values:
0
2
3
f
f
a
c
2

llvm/test/tools/llvm-profdata/Inputs/mcdc-4.proftext

  • This file was added.
test3
# Func Hash:
15288018065
# Num Counters:
6
# Counter Values:
4
2
1
0
0
2
# Num Bitmask Bytes:
$8
# Bitmask Byte Values:
1
2
3
4
5
6
7
8

llvm/test/tools/llvm-profdata/Inputs/mcdc-err0.proftext

  • This file was added.
test3
# Func Hash:
15288018065
# Num Counters:
6
# Counter Values:
4
2
1
0
0
2
# Num Bitmask Bytes:
$8.9
# Bitmask Byte Values:
1
2
3
4
5
6
7
8

llvm/test/tools/llvm-profdata/Inputs/mcdc-err1.proftext

  • This file was added.
test3
# Func Hash:
15288018065
# Num Counters:
6
# Counter Values:
4
2
1
0
0
2
# Num Bitmask Bytes:
$8
# Bitmask Byte Values:
1
2
3
4
5.4
6
7
8

llvm/test/tools/llvm-profdata/binary-ids-padding.test

// Header // Header
// //
// INSTR_PROF_RAW_HEADER(uint64_t, Magic, __llvm_profile_get_magic()) // INSTR_PROF_RAW_HEADER(uint64_t, Magic, __llvm_profile_get_magic())
// INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version()) // INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version())
// INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL)) // INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL))
// INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize) // INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize)
// INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize) // INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize)
// INSTR_PROF_RAW_HEADER(uint64_t, NumBitmaskBytes, NumBitmaskBytes)
// INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize) // INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize)
// INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin) // INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, BitmaskDelta, (uintptr_t)BitmaskBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin) // INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last) // INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last)
RUN: printf '\201rforpl\377' > %t.profraw RUN: printf '\201rforpl\377' > %t.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw
// There will be 2 20-byte binary IDs, so the total Binary IDs size will be 64 bytes. // There will be 2 20-byte binary IDs, so the total Binary IDs size will be 64 bytes.
// 2 * 8 binary ID sizes // 2 * 8 binary ID sizes
// + 2 * 20 binary IDs (of size 20) // + 2 * 20 binary IDs (of size 20)
// + 2 * 4 binary ID paddings // + 2 * 4 binary ID paddings
// -------- // --------
// = 64 bytes // = 64 bytes
RUN: printf '\100\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\100\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\2\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\2\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\3\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\3\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\20\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\20\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\4\0\2\0\0\0' >> %t.profraw RUN: printf '\0\0\4\0\2\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
// Binary IDs - There are only two in this case that are 20 bytes. // Binary IDs - There are only two in this case that are 20 bytes.
RUN: printf '\24\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\24\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\1\2\3\4\5\6\7' >> %t.profraw RUN: printf '\0\1\2\3\4\5\6\7' >> %t.profraw
RUN: printf '\0\1\2\3\4\5\6\7' >> %t.profraw RUN: printf '\0\1\2\3\4\5\6\7' >> %t.profraw
RUN: printf '\0\1\2\3\0\0\0\0' >> %t.profraw RUN: printf '\0\1\2\3\0\0\0\0' >> %t.profraw
Show All 10 Lines
// #include "llvm/ProfileData/InstrProfData.inc" // #include "llvm/ProfileData/InstrProfData.inc"
// }; // };
RUN: printf '\254\275\030\333\114\302\370\134' >> %t.profraw RUN: printf '\254\275\030\333\114\302\370\134' >> %t.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\067\265\035\031\112\165\023\344' >> %t.profraw RUN: printf '\067\265\035\031\112\165\023\344' >> %t.profraw
RUN: printf '\02\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\02\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\xd8\xff\3\0\1\0\0\0' >> %t.profraw RUN: printf '\xc8\xff\3\0\1\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\02\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\02\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\023\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\023\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\067\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\067\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\101\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\101\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\7\0foo\1bar\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\7\0foo\1bar\0\0\0\0\0\0\0' >> %t.profraw
// RUN: llvm-profdata show --binary-ids %t.profraw | FileCheck %s // RUN: llvm-profdata show --binary-ids %t.profraw | FileCheck %s
// CHECK: Instrumentation level: Front-end // CHECK: Instrumentation level: Front-end
// CHECK: Binary IDs: // CHECK: Binary IDs:
// CHECK-NEXT: 0001020304050607000102030405060700010203 // CHECK-NEXT: 0001020304050607000102030405060700010203
// CHECK-NEXT: 0101010101010101020202020202020203030303 // CHECK-NEXT: 0101010101010101020202020202020203030303

llvm/test/tools/llvm-profdata/large-binary-id-size.test

RUN: printf '\201rforpl\377' > %t.profraw RUN: printf '\201rforpl\377' > %t.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\40\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\40\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
// Check for a corrupted size being too large past the end of the file. // Check for a corrupted size being too large past the end of the file.
RUN: printf '\7\7\7\7\7\7\7\7' >> %t.profraw RUN: printf '\7\7\7\7\7\7\7\7' >> %t.profraw
RUN: printf '\0\1\2\3\4\5\6\7' >> %t.profraw RUN: printf '\0\1\2\3\4\5\6\7' >> %t.profraw
RUN: printf '\0\1\2\3\4\5\6\7' >> %t.profraw RUN: printf '\0\1\2\3\4\5\6\7' >> %t.profraw
RUN: printf '\0\1\2\3\0\0\0\0' >> %t.profraw RUN: printf '\0\1\2\3\0\0\0\0' >> %t.profraw
// RUN: not llvm-profdata show --binary-ids %t.profraw 2>&1 | FileCheck %s // RUN: not llvm-profdata show --binary-ids %t.profraw 2>&1 | FileCheck %s
// CHECK: malformed instrumentation profile data: not enough data to read binary id data // CHECK: malformed instrumentation profile data: not enough data to read binary id data

llvm/test/tools/llvm-profdata/malformed-not-space-for-another-header.test

// Header // Header
// //
// INSTR_PROF_RAW_HEADER(uint64_t, Magic, __llvm_profile_get_magic()) // INSTR_PROF_RAW_HEADER(uint64_t, Magic, __llvm_profile_get_magic())
// INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version()) // INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version())
// INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL)) // INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL))
// INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize) // INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize)
// INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize) // INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize)
// INSTR_PROF_RAW_HEADER(uint64_t, NumBitmaskBytes, NumBitmaskBytes)
// INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize) // INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize)
// INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin) // INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, BitmaskDelta, (uintptr_t)BitmaskBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin) // INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last) // INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last)
RUN: printf '\201rforpl\377' > %t.profraw RUN: printf '\201rforpl\377' > %t.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\4\0\2\0\0\0' >> %t.profraw RUN: printf '\0\0\4\0\2\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
// Data Section // Data Section
// //
// struct ProfData { // struct ProfData {
// #define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer) \ // #define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer) \
// Type Name; // Type Name;
// #include "llvm/ProfileData/InstrProfData.inc" // #include "llvm/ProfileData/InstrProfData.inc"
// }; // };
RUN: printf '\254\275\030\333\114\302\370\134' >> %t.profraw RUN: printf '\254\275\030\333\114\302\370\134' >> %t.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\023\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\023\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\3\0foo\0\0\0' >> %t.profraw RUN: printf '\3\0foo\0\0\0' >> %t.profraw
// Write some garbage data at the end so we get "not enough space for another header" message // Write some garbage data at the end so we get "not enough space for another header" message
RUN: printf '\x03\x00\' >> %t.profraw RUN: printf '\x03\x00\' >> %t.profraw
RUN: not llvm-profdata show %t.profraw 2>&1 | FileCheck %s RUN: not llvm-profdata show %t.profraw 2>&1 | FileCheck %s
CHECK: malformed instrumentation profile data: not enough space for another header CHECK: malformed instrumentation profile data: not enough space for another header

llvm/test/tools/llvm-profdata/malformed-num-counters-zero.test

// Header // Header
// //
// INSTR_PROF_RAW_HEADER(uint64_t, Magic, __llvm_profile_get_magic()) // INSTR_PROF_RAW_HEADER(uint64_t, Magic, __llvm_profile_get_magic())
// INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version()) // INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version())
// INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL)) // INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL))
// INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize) // INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize)
// INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize) // INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize)
// INSTR_PROF_RAW_HEADER(uint64_t, NumBitmaskBytes, NumBitmaskBytes)
// INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize) // INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize)
// INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin) // INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, BitmaskDelta, (uintptr_t)BitmaskBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin) // INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last) // INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last)
RUN: printf '\201rforpl\377' > %t.profraw RUN: printf '\201rforpl\377' > %t.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\4\0\2\0\0\0' >> %t.profraw RUN: printf '\0\0\4\0\2\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
// Data Section // Data Section
// //
// struct ProfData { // struct ProfData {
// #define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer) \ // #define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer) \
// Type Name; // Type Name;
// #include "llvm/ProfileData/InstrProfData.inc" // #include "llvm/ProfileData/InstrProfData.inc"
// }; // };
RUN: printf '\254\275\030\333\114\302\370\134' >> %t.profraw RUN: printf '\254\275\030\333\114\302\370\134' >> %t.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw RUN: printf '\0\0\4\0\1\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
// Make NumCounters = 0 so that we get "number of counters is zero" error message // Make NumCounters = 0 so that we get "number of counters is zero" error message
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\023\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\023\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\3\0foo\0\0\0' >> %t.profraw RUN: printf '\3\0foo\0\0\0' >> %t.profraw
RUN: not llvm-profdata show %t.profraw 2>&1 | FileCheck %s RUN: not llvm-profdata show %t.profraw 2>&1 | FileCheck %s
CHECK: malformed instrumentation profile data: number of counters is zero CHECK: malformed instrumentation profile data: number of counters is zero

llvm/test/tools/llvm-profdata/malformed-ptr-to-counter-array.test

// Header // Header
// //
// INSTR_PROF_RAW_HEADER(uint64_t, Magic, __llvm_profile_get_magic()) // INSTR_PROF_RAW_HEADER(uint64_t, Magic, __llvm_profile_get_magic())
// INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version()) // INSTR_PROF_RAW_HEADER(uint64_t, Version, __llvm_profile_get_version())
// INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL)) // INSTR_PROF_RAW_HEADER(uint64_t, BinaryIdsSize, __llvm_write_binary_ids(NULL))
// INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize) // INSTR_PROF_RAW_HEADER(uint64_t, DataSize, DataSize)
// INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize) // INSTR_PROF_RAW_HEADER(uint64_t, CountersSize, CountersSize)
// INSTR_PROF_RAW_HEADER(uint64_t, NumBitmaskBytes, NumBitmaskBytes)
// INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize) // INSTR_PROF_RAW_HEADER(uint64_t, NamesSize, NamesSize)
// INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin) // INSTR_PROF_RAW_HEADER(uint64_t, CountersDelta, (uintptr_t)CountersBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, BitmaskDelta, (uintptr_t)BitmaskBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin) // INSTR_PROF_RAW_HEADER(uint64_t, NamesDelta, (uintptr_t)NamesBegin)
// INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last) // INSTR_PROF_RAW_HEADER(uint64_t, ValueKindLast, IPVK_Last)
RUN: printf '\201rforpl\377' > %t.profraw RUN: printf '\201rforpl\377' > %t.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\2\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\2\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\6\0\1\0\0\0' >> %t.profraw RUN: printf '\0\0\6\0\1\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\6\0\2\0\0\0' >> %t.profraw RUN: printf '\0\0\6\0\2\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
// Data Section // Data Section
// //
// struct ProfData { // struct ProfData {
// #define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer) \ // #define INSTR_PROF_DATA(Type, LLVMType, Name, Initializer) \
// Type Name; // Type Name;
// #include "llvm/ProfileData/InstrProfData.inc" // #include "llvm/ProfileData/InstrProfData.inc"
// }; // };
RUN: printf '\067\265\035\031\112\165\023\344' >> %t.profraw RUN: printf '\067\265\035\031\112\165\023\344' >> %t.profraw
RUN: printf '\02\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\02\0\0\0\0\0\0\0' >> %t.profraw
// Note: The CounterPtr here is off-by-one. // Note: The CounterPtr here is off-by-one.
// //
// Octal '\11' is 9 in decimal: this should push CounterOffset to 1. As there are two counters, // Octal '\11' is 9 in decimal: this should push CounterOffset to 1. As there are two counters,
// the profile reader should error out. // the profile reader should error out.
RUN: printf '\11\0\6\0\1\0\0\0' >> %t.profraw RUN: printf '\11\0\6\0\1\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\02\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\02\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t.profraw
// Counter Section // Counter Section
RUN: printf '\067\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\067\0\0\0\0\0\0\0' >> %t.profraw
RUN: printf '\101\0\0\0\0\0\0\0' >> %t.profraw RUN: printf '\101\0\0\0\0\0\0\0' >> %t.profraw
// Name Section // Name Section
RUN: printf '\3\0bar\0\0\0' >> %t.profraw RUN: printf '\3\0bar\0\0\0' >> %t.profraw
RUN: not llvm-profdata merge -o /dev/null %t.profraw 2>&1 | FileCheck %s RUN: not llvm-profdata merge -o /dev/null %t.profraw 2>&1 | FileCheck %s
CHECK: warning: {{.+}}: malformed instrumentation profile data: number of counters 2 is greater than the maximum number of counters 0 CHECK: warning: {{.+}}: malformed instrumentation profile data: number of counters 2 is greater than the maximum number of counters 0
CHECK: error: no profile can be merged CHECK: error: no profile can be merged

llvm/test/tools/llvm-profdata/mcdc-bitmask.test

  • This file was added.
# Test MC/DC bitmask reading and merging.
# Merge as profdata.
RUN: llvm-profdata merge %p/Inputs/mcdc-1.proftext %p/Inputs/mcdc-2.proftext -o %t.profdata
RUN: llvm-profdata show %t.profdata --text -all-functions | FileCheck %s --check-prefix=MCDC
# Merge as proftext.
RUN: llvm-profdata merge %p/Inputs/mcdc-1.proftext %p/Inputs/mcdc-2.proftext -o %t.proftext
RUN: llvm-profdata show %t.proftext --text -all-functions | FileCheck %s --check-prefix=MCDC
MCDC: # Num Bitmask Bytes:
MCDC-NEXT: $1
MCDC-NEXT: # Bitmask Byte Values:
MCDC-NEXT: a
MCDC: # Num Bitmask Bytes:
MCDC-NEXT: $2
MCDC-NEXT: # Bitmask Byte Values:
MCDC-NEXT: 29
MCDC-NEXT: 0
# Merge as profdata.
RUN: llvm-profdata merge %p/Inputs/mcdc-3.proftext %p/Inputs/mcdc-4.proftext -o %t.profdata
RUN: llvm-profdata show %t.profdata --text -all-functions | FileCheck %s --check-prefix=MCDC2
# Merge as proftext.
RUN: llvm-profdata merge %p/Inputs/mcdc-3.proftext %p/Inputs/mcdc-4.proftext -o %t.proftext
RUN: llvm-profdata show %t.proftext --text -all-functions | FileCheck %s --check-prefix=MCDC2
MCDC2: # Num Bitmask Bytes:
MCDC2-NEXT: $8
MCDC2-NEXT: # Bitmask Byte Values:
MCDC2-NEXT: 1
MCDC2-NEXT: 2
MCDC2-NEXT: 3
MCDC2-NEXT: f
MCDC2-NEXT: f
MCDC2-NEXT: e
MCDC2-NEXT: f
MCDC2-NEXT: a
# Incompatible size mismatch.
RUN: llvm-profdata merge %p/Inputs/mcdc-2.proftext %p/Inputs/mcdc-4.proftext -o %t.profdata 2>&1 | FileCheck %s --check-prefix=MCDC3
# Merge as proftext
RUN: llvm-profdata merge %p/Inputs/mcdc-2.proftext %p/Inputs/mcdc-4.proftext -o %t.proftext 2>&1 | FileCheck %s --check-prefix=MCDC3
MCDC3: function bitmask size change detected (bitmask size mismatch)
# Invalid number of bitmask bytes.
RUN: not llvm-profdata merge %p/Inputs/mcdc-3.proftext %p/Inputs/mcdc-err0.proftext -o %t.proftext 2>&1 | FileCheck %s --check-prefix=MCDC4
MCDC4: malformed instrumentation profile data: number of bitmasks is not a valid integer
# Invalid bitmask byte.
RUN: not llvm-profdata merge %p/Inputs/mcdc-3.proftext %p/Inputs/mcdc-err1.proftext -o %t.proftext 2>&1 | FileCheck %s --check-prefix=MCDC5
MCDC5: malformed instrumentation profile data: bitmask byte is invalid

llvm/test/tools/llvm-profdata/raw-32-bits-be.test

RUN: printf '\377lprofR\201' > %t RUN: printf '\377lprofR\201' > %t
RUN: printf '\0\0\0\0\0\0\0\10' >> %t RUN: printf '\0\0\0\0\0\0\0\10' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\2' >> %t RUN: printf '\0\0\0\0\0\0\0\2' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\3' >> %t RUN: printf '\0\0\0\0\0\0\0\3' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\4' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\20' >> %t RUN: printf '\0\0\0\0\0\0\0\20' >> %t
RUN: printf '\0\0\0\0\1\0\0\0' >> %t RUN: printf '\0\0\0\0\1\0\0\0' >> %t
RUN: printf '\0\0\0\0\3\0\0\0' >> %t
RUN: printf '\0\0\0\0\2\0\0\0' >> %t RUN: printf '\0\0\0\0\2\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\134\370\302\114\333\030\275\254' >> %t RUN: printf '\134\370\302\114\333\030\275\254' >> %t
RUN: printf '\0\0\0\0\0\0\0\1' >> %t RUN: printf '\0\0\0\0\0\0\0\1' >> %t
RUN: printf '\1\0\0\0' >> %t RUN: printf '\1\0\0\0' >> %t
RUN: printf '\3\0\0\0' >> %t
RUN: printf '\0\0\0\0' >> %t RUN: printf '\0\0\0\0' >> %t
RUN: printf '\0\0\0\0' >> %t RUN: printf '\0\0\0\0' >> %t
RUN: printf '\0\0\0\1' >> %t RUN: printf '\0\0\0\1' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\3' >> %t
RUN: printf '\0\0\0\0' >> %t
RUN: printf '\344\023\165\112\031\035\265\067' >> %t RUN: printf '\344\023\165\112\031\035\265\067' >> %t
RUN: printf '\0\0\0\0\0\0\0\2' >> %t RUN: printf '\0\0\0\0\0\0\0\2' >> %t
RUN: printf '\0\xff\xff\xe0' >> %t RUN: printf '\0\xff\xff\xd8' >> %t
RUN: printf '\2\xff\xff\xd3' >> %t
RUN: printf '\0\0\0\0' >> %t RUN: printf '\0\0\0\0' >> %t
RUN: printf '\0\0\0\0' >> %t RUN: printf '\0\0\0\0' >> %t
RUN: printf '\0\0\0\2' >> %t RUN: printf '\0\0\0\2' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\1' >> %t
RUN: printf '\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\023' >> %t RUN: printf '\0\0\0\0\0\0\0\023' >> %t
RUN: printf '\0\0\0\0\0\0\0\067' >> %t RUN: printf '\0\0\0\0\0\0\0\067' >> %t
RUN: printf '\0\0\0\0\0\0\0\101' >> %t RUN: printf '\0\0\0\0\0\0\0\101' >> %t
RUN: printf '\125\125\125\052' >> %t
RUN: printf '\7\0foo\1bar\0\0\0\0\0\0\0' >> %t RUN: printf '\7\0foo\1bar\0\0\0\0\0\0\0' >> %t
RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s
RUN: llvm-profdata show %t -all-functions -text | FileCheck %s -check-prefix=MCDC
CHECK: Counters: CHECK: Counters:
CHECK: foo: CHECK: foo:
CHECK: Hash: 0x0000000000000001 CHECK: Hash: 0x0000000000000001
CHECK: Counters: 1 CHECK: Counters: 1
CHECK: Function count: 19 CHECK: Function count: 19
CHECK: Block counts: [] CHECK: Block counts: []
CHECK: bar: CHECK: bar:
CHECK: Hash: 0x0000000000000002 CHECK: Hash: 0x0000000000000002
CHECK: Counters: 2 CHECK: Counters: 2
CHECK: Function count: 55 CHECK: Function count: 55
CHECK: Block counts: [65] CHECK: Block counts: [65]
CHECK: Functions shown: 2 CHECK: Functions shown: 2
CHECK: Total functions: 2 CHECK: Total functions: 2
CHECK: Maximum function count: 55 CHECK: Maximum function count: 55
CHECK: Maximum internal block count: 65 CHECK: Maximum internal block count: 65
MCDC: Num Bitmask Bytes:
MCDC-NEXT: $3
MCDC-NEXT: Bitmask Byte Values:
MCDC-NEXT: 55
MCDC-NEXT: 55
MCDC-NEXT: 55
MCDC: Num Bitmask Bytes:
MCDC-NEXT: $1
MCDC-NEXT: Bitmask Byte Values:
MCDC-NEXT: 2a

llvm/test/tools/llvm-profdata/raw-32-bits-le.test

RUN: printf '\201Rforpl\377' > %t RUN: printf '\201Rforpl\377' > %t
RUN: printf '\10\0\0\0\0\0\0\0' >> %t RUN: printf '\10\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\2\0\0\0\0\0\0\0' >> %t RUN: printf '\2\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\3\0\0\0\0\0\0\0' >> %t RUN: printf '\3\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\4\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\20\0\0\0\0\0\0\0' >> %t RUN: printf '\20\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\1\0\0\0\0' >> %t RUN: printf '\0\0\0\1\0\0\0\0' >> %t
RUN: printf '\0\0\0\3\0\0\0\0' >> %t
RUN: printf '\0\0\0\2\0\0\0\0' >> %t RUN: printf '\0\0\0\2\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\254\275\030\333\114\302\370\134' >> %t RUN: printf '\254\275\030\333\114\302\370\134' >> %t
RUN: printf '\1\0\0\0\0\0\0\0' >> %t RUN: printf '\1\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\1' >> %t RUN: printf '\0\0\0\1' >> %t
RUN: printf '\0\0\0\3' >> %t
RUN: printf '\0\0\0\0' >> %t RUN: printf '\0\0\0\0' >> %t
RUN: printf '\0\0\0\0' >> %t RUN: printf '\0\0\0\0' >> %t
RUN: printf '\1\0\0\0' >> %t RUN: printf '\1\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\3\0\0\0' >> %t
RUN: printf '\0\0\0\0' >> %t
RUN: printf '\067\265\035\031\112\165\023\344' >> %t RUN: printf '\067\265\035\031\112\165\023\344' >> %t
RUN: printf '\02\0\0\0\0\0\0\0' >> %t RUN: printf '\02\0\0\0\0\0\0\0' >> %t
RUN: printf '\xe0\xff\xff\0' >> %t RUN: printf '\xd8\xff\xff\0' >> %t
RUN: printf '\xd3\xff\xff\2' >> %t
RUN: printf '\0\0\0\0' >> %t RUN: printf '\0\0\0\0' >> %t
RUN: printf '\0\0\0\0' >> %t RUN: printf '\0\0\0\0' >> %t
RUN: printf '\2\0\0\0' >> %t RUN: printf '\2\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\1\0\0\0' >> %t
RUN: printf '\0\0\0\0' >> %t
RUN: printf '\023\0\0\0\0\0\0\0' >> %t RUN: printf '\023\0\0\0\0\0\0\0' >> %t
RUN: printf '\067\0\0\0\0\0\0\0' >> %t RUN: printf '\067\0\0\0\0\0\0\0' >> %t
RUN: printf '\101\0\0\0\0\0\0\0' >> %t RUN: printf '\101\0\0\0\0\0\0\0' >> %t
RUN: printf '\125\125\125\052' >> %t
RUN: printf '\7\0foo\1bar\0\0\0\0\0\0\0' >> %t RUN: printf '\7\0foo\1bar\0\0\0\0\0\0\0' >> %t
RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s
RUN: llvm-profdata show %t -all-functions -text | FileCheck %s -check-prefix=MCDC
CHECK: Counters: CHECK: Counters:
CHECK: foo: CHECK: foo:
CHECK: Hash: 0x0000000000000001 CHECK: Hash: 0x0000000000000001
CHECK: Counters: 1 CHECK: Counters: 1
CHECK: Function count: 19 CHECK: Function count: 19
CHECK: Block counts: [] CHECK: Block counts: []
CHECK: bar: CHECK: bar:
CHECK: Hash: 0x0000000000000002 CHECK: Hash: 0x0000000000000002
CHECK: Counters: 2 CHECK: Counters: 2
CHECK: Function count: 55 CHECK: Function count: 55
CHECK: Block counts: [65] CHECK: Block counts: [65]
CHECK: Functions shown: 2 CHECK: Functions shown: 2
CHECK: Total functions: 2 CHECK: Total functions: 2
CHECK: Maximum function count: 55 CHECK: Maximum function count: 55
CHECK: Maximum internal block count: 65 CHECK: Maximum internal block count: 65
MCDC: Num Bitmask Bytes:
MCDC-NEXT: $3
MCDC-NEXT: Bitmask Byte Values:
MCDC-NEXT: 55
MCDC-NEXT: 55
MCDC-NEXT: 55
MCDC: Num Bitmask Bytes:
MCDC-NEXT: $1
MCDC-NEXT: Bitmask Byte Values:
MCDC-NEXT: 2a

llvm/test/tools/llvm-profdata/raw-64-bits-be.test

RUN: printf '\377lprofr\201' > %t RUN: printf '\377lprofr\201' > %t
RUN: printf '\0\0\0\0\0\0\0\10' >> %t RUN: printf '\0\0\0\0\0\0\0\10' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\2' >> %t RUN: printf '\0\0\0\0\0\0\0\2' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\3' >> %t RUN: printf '\0\0\0\0\0\0\0\3' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\4' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\20' >> %t RUN: printf '\0\0\0\0\0\0\0\20' >> %t
RUN: printf '\0\0\0\1\0\4\0\0' >> %t RUN: printf '\0\0\0\1\0\4\0\0' >> %t
RUN: printf '\0\0\0\3\0\4\0\0' >> %t
RUN: printf '\0\0\0\2\0\4\0\0' >> %t RUN: printf '\0\0\0\2\0\4\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\134\370\302\114\333\030\275\254' >> %t RUN: printf '\134\370\302\114\333\030\275\254' >> %t
RUN: printf '\0\0\0\0\0\0\0\1' >> %t RUN: printf '\0\0\0\0\0\0\0\1' >> %t
RUN: printf '\0\0\0\1\0\4\0\0' >> %t RUN: printf '\0\0\0\1\0\4\0\0' >> %t
RUN: printf '\0\0\0\3\0\4\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\1\0\0\0\0' >> %t RUN: printf '\0\0\0\1\0\0\0\0' >> %t
RUN: printf '\0\0\0\3\0\0\0\0' >> %t
RUN: printf '\344\023\165\112\031\035\265\067' >> %t RUN: printf '\344\023\165\112\031\035\265\067' >> %t
RUN: printf '\0\0\0\0\0\0\0\02' >> %t RUN: printf '\0\0\0\0\0\0\0\02' >> %t
RUN: printf '\0\0\0\1\0\3\xff\xd8' >> %t RUN: printf '\0\0\0\1\0\3\xff\xc8' >> %t
RUN: printf '\0\0\0\3\0\3\xff\xc3' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\02\0\0\0\0' >> %t RUN: printf '\0\0\0\02\0\0\0\0' >> %t
RUN: printf '\0\0\0\1\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\023' >> %t RUN: printf '\0\0\0\0\0\0\0\023' >> %t
RUN: printf '\0\0\0\0\0\0\0\067' >> %t RUN: printf '\0\0\0\0\0\0\0\067' >> %t
RUN: printf '\0\0\0\0\0\0\0\101' >> %t RUN: printf '\0\0\0\0\0\0\0\101' >> %t
RUN: printf '\125\125\125\052' >> %t
RUN: printf '\7\0foo\1bar\0\0\0\0\0\0\0' >> %t RUN: printf '\7\0foo\1bar\0\0\0\0\0\0\0' >> %t
RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s
RUN: llvm-profdata show %t -all-functions -text | FileCheck %s -check-prefix=MCDC
CHECK: Counters: CHECK: Counters:
CHECK: foo: CHECK: foo:
CHECK: Hash: 0x0000000000000001 CHECK: Hash: 0x0000000000000001
CHECK: Counters: 1 CHECK: Counters: 1
CHECK: Function count: 19 CHECK: Function count: 19
CHECK: Block counts: [] CHECK: Block counts: []
CHECK: bar: CHECK: bar:
CHECK: Hash: 0x0000000000000002 CHECK: Hash: 0x0000000000000002
CHECK: Counters: 2 CHECK: Counters: 2
CHECK: Function count: 55 CHECK: Function count: 55
CHECK: Block counts: [65] CHECK: Block counts: [65]
CHECK: Functions shown: 2 CHECK: Functions shown: 2
CHECK: Total functions: 2 CHECK: Total functions: 2
CHECK: Maximum function count: 55 CHECK: Maximum function count: 55
CHECK: Maximum internal block count: 65 CHECK: Maximum internal block count: 65
MCDC: Num Bitmask Bytes:
MCDC-NEXT: $3
MCDC-NEXT: Bitmask Byte Values:
MCDC-NEXT: 55
MCDC-NEXT: 55
MCDC-NEXT: 55
MCDC: Num Bitmask Bytes:
MCDC-NEXT: $1
MCDC-NEXT: Bitmask Byte Values:
MCDC-NEXT: 2a

llvm/test/tools/llvm-profdata/raw-64-bits-le.test

RUN: printf '\201rforpl\377' > %t RUN: printf '\201rforpl\377' > %t
RUN: printf '\10\0\0\0\0\0\0\0' >> %t RUN: printf '\10\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\2\0\0\0\0\0\0\0' >> %t RUN: printf '\2\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\3\0\0\0\0\0\0\0' >> %t RUN: printf '\3\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\4\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\20\0\0\0\0\0\0\0' >> %t RUN: printf '\20\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\4\0\1\0\0\0' >> %t RUN: printf '\0\0\4\0\1\0\0\0' >> %t
RUN: printf '\0\0\4\0\3\0\0\0' >> %t
RUN: printf '\0\0\4\0\2\0\0\0' >> %t RUN: printf '\0\0\4\0\2\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\254\275\030\333\114\302\370\134' >> %t RUN: printf '\254\275\030\333\114\302\370\134' >> %t
RUN: printf '\1\0\0\0\0\0\0\0' >> %t RUN: printf '\1\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\4\0\1\0\0\0' >> %t RUN: printf '\0\0\4\0\1\0\0\0' >> %t
RUN: printf '\0\0\4\0\3\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\1\0\0\0\0\0\0\0' >> %t RUN: printf '\1\0\0\0\0\0\0\0' >> %t
RUN: printf '\3\0\0\0\0\0\0\0' >> %t
RUN: printf '\067\265\035\031\112\165\023\344' >> %t RUN: printf '\067\265\035\031\112\165\023\344' >> %t
RUN: printf '\02\0\0\0\0\0\0\0' >> %t RUN: printf '\02\0\0\0\0\0\0\0' >> %t
RUN: printf '\xd8\xff\3\0\1\0\0\0' >> %t RUN: printf '\xc8\xff\3\0\1\0\0\0' >> %t
RUN: printf '\xc3\xff\3\0\3\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\0\0\0\0\0\0\0\0' >> %t RUN: printf '\0\0\0\0\0\0\0\0' >> %t
RUN: printf '\02\0\0\0\0\0\0\0' >> %t RUN: printf '\02\0\0\0\0\0\0\0' >> %t
RUN: printf '\1\0\0\0\0\0\0\0' >> %t
RUN: printf '\023\0\0\0\0\0\0\0' >> %t RUN: printf '\023\0\0\0\0\0\0\0' >> %t
RUN: printf '\067\0\0\0\0\0\0\0' >> %t RUN: printf '\067\0\0\0\0\0\0\0' >> %t
RUN: printf '\101\0\0\0\0\0\0\0' >> %t RUN: printf '\101\0\0\0\0\0\0\0' >> %t
RUN: printf '\125\125\125\052' >> %t
RUN: printf '\7\0foo\1bar\0\0\0\0\0\0\0' >> %t RUN: printf '\7\0foo\1bar\0\0\0\0\0\0\0' >> %t
RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s RUN: llvm-profdata show %t -all-functions -counts | FileCheck %s
RUN: llvm-profdata show %t -all-functions -text | FileCheck %s -check-prefix=MCDC
CHECK: Counters: CHECK: Counters:
CHECK: foo: CHECK: foo:
CHECK: Hash: 0x0000000000000001 CHECK: Hash: 0x0000000000000001
CHECK: Counters: 1 CHECK: Counters: 1
CHECK: Function count: 19 CHECK: Function count: 19
CHECK: Block counts: [] CHECK: Block counts: []
CHECK: bar: CHECK: bar:
CHECK: Hash: 0x0000000000000002 CHECK: Hash: 0x0000000000000002
CHECK: Counters: 2 CHECK: Counters: 2
CHECK: Function count: 55 CHECK: Function count: 55
CHECK: Block counts: [65] CHECK: Block counts: [65]
CHECK: Functions shown: 2 CHECK: Functions shown: 2
CHECK: Total functions: 2 CHECK: Total functions: 2
CHECK: Maximum function count: 55 CHECK: Maximum function count: 55
CHECK: Maximum internal block count: 65 CHECK: Maximum internal block count: 65
MCDC: Num Bitmask Bytes:
MCDC-NEXT: $3
MCDC-NEXT: Bitmask Byte Values:
MCDC-NEXT: 55
MCDC-NEXT: 55
MCDC-NEXT: 55
MCDC: Num Bitmask Bytes:
MCDC-NEXT: $1
MCDC-NEXT: Bitmask Byte Values:
MCDC-NEXT: 2a

llvm/test/tools/llvm-profdata/raw-two-profiles.test

RUN: printf '\201rforpl\377' > %t-foo.profraw RUN: printf '\201rforpl\377' > %t-foo.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\4\0\1\0\0\0' >> %t-foo.profraw RUN: printf '\0\0\4\0\1\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\4\0\2\0\0\0' >> %t-foo.profraw RUN: printf '\0\0\4\0\2\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\254\275\030\333\114\302\370\134' >> %t-foo.profraw RUN: printf '\254\275\030\333\114\302\370\134' >> %t-foo.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\4\0\1\0\0\0' >> %t-foo.profraw RUN: printf '\0\0\4\0\1\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\023\0\0\0\0\0\0\0' >> %t-foo.profraw RUN: printf '\023\0\0\0\0\0\0\0' >> %t-foo.profraw
RUN: printf '\3\0foo\0\0\0' >> %t-foo.profraw RUN: printf '\3\0foo\0\0\0' >> %t-foo.profraw
RUN: printf '\201rforpl\377' > %t-bar.profraw RUN: printf '\201rforpl\377' > %t-bar.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\1\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\1\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\2\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\2\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\10\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\10\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\6\0\1\0\0\0' >> %t-bar.profraw RUN: printf '\0\0\6\0\1\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\6\0\2\0\0\0' >> %t-bar.profraw RUN: printf '\0\0\6\0\2\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\067\265\035\031\112\165\023\344' >> %t-bar.profraw RUN: printf '\067\265\035\031\112\165\023\344' >> %t-bar.profraw
RUN: printf '\02\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\02\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\6\0\1\0\0\0' >> %t-bar.profraw RUN: printf '\0\0\6\0\1\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\02\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\02\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\0\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\067\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\067\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\101\0\0\0\0\0\0\0' >> %t-bar.profraw RUN: printf '\101\0\0\0\0\0\0\0' >> %t-bar.profraw
RUN: printf '\3\0bar\0\0\0' >> %t-bar.profraw RUN: printf '\3\0bar\0\0\0' >> %t-bar.profraw
RUN: cat %t-foo.profraw %t-bar.profraw > %t-pad.profraw RUN: cat %t-foo.profraw %t-bar.profraw > %t-pad.profraw
RUN: llvm-profdata show %t-pad.profraw -all-functions -counts | FileCheck %s RUN: llvm-profdata show %t-pad.profraw -all-functions -counts | FileCheck %s
Show All 15 Lines

llvm/tools/llvm-cov/CodeCoverage.cpp

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lines void attachExpansionSubViews(SourceCoverageView &View,
const CoverageMapping &Coverage); const CoverageMapping &Coverage);
/// Create source views for the branches of the view. /// Create source views for the branches of the view.
void attachBranchSubViews(SourceCoverageView &View, StringRef SourceName, void attachBranchSubViews(SourceCoverageView &View, StringRef SourceName,
ArrayRef<CountedRegion> Branches, ArrayRef<CountedRegion> Branches,
const MemoryBuffer &File, const MemoryBuffer &File,
CoverageData &CoverageInfo); CoverageData &CoverageInfo);
/// Create source views for the MCDC records.
void attachMCDCSubViews(SourceCoverageView &View, StringRef SourceName,
ArrayRef<MCDCRecord> MCDCRecords,
const MemoryBuffer &File, CoverageData &CoverageInfo);
/// Create the source view of a particular function. /// Create the source view of a particular function.
std::unique_ptr<SourceCoverageView> std::unique_ptr<SourceCoverageView>
createFunctionView(const FunctionRecord &Function, createFunctionView(const FunctionRecord &Function,
const CoverageMapping &Coverage); const CoverageMapping &Coverage);
/// Create the main source view of a particular source file. /// Create the main source view of a particular source file.
std::unique_ptr<SourceCoverageView> std::unique_ptr<SourceCoverageView>
createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage); createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage);
▲ Show 20 Lines • Show All 226 Lines • ▼ Show 20 Lines while (NextBranch != EndBranch) {
if (!ViewBranches.empty()) { if (!ViewBranches.empty()) {
auto SubView = SourceCoverageView::create(SourceName, File, ViewOpts, auto SubView = SourceCoverageView::create(SourceName, File, ViewOpts,
std::move(CoverageInfo)); std::move(CoverageInfo));
View.addBranch(CurrentLine, ViewBranches, std::move(SubView)); View.addBranch(CurrentLine, ViewBranches, std::move(SubView));
} }
} }
} }
void CodeCoverageTool::attachMCDCSubViews(SourceCoverageView &View,
StringRef SourceName,
ArrayRef<MCDCRecord> MCDCRecords,
const MemoryBuffer &File,
CoverageData &CoverageInfo) {
if (!ViewOpts.ShowMCDC)
return;
const auto *NextRecord = MCDCRecords.begin();
const auto *EndRecord = MCDCRecords.end();
// Group and process MCDC records that have the same line number into the
// same subview.
while (NextRecord != EndRecord) {
std::vector<MCDCRecord> ViewMCDCRecords;
unsigned CurrentLine = NextRecord->getDecisionRegion().LineEnd;
while (NextRecord != EndRecord &&
CurrentLine == NextRecord->getDecisionRegion().LineEnd) {
ViewMCDCRecords.push_back(*NextRecord++);
}
if (!ViewMCDCRecords.empty()) {
auto SubView = SourceCoverageView::create(SourceName, File, ViewOpts,
std::move(CoverageInfo));
View.addMCDCRecord(CurrentLine, ViewMCDCRecords, std::move(SubView));
}
}
}
std::unique_ptr<SourceCoverageView> std::unique_ptr<SourceCoverageView>
CodeCoverageTool::createFunctionView(const FunctionRecord &Function, CodeCoverageTool::createFunctionView(const FunctionRecord &Function,
const CoverageMapping &Coverage) { const CoverageMapping &Coverage) {
auto FunctionCoverage = Coverage.getCoverageForFunction(Function); auto FunctionCoverage = Coverage.getCoverageForFunction(Function);
if (FunctionCoverage.empty()) if (FunctionCoverage.empty())
return nullptr; return nullptr;
auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename()); auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename());
if (!SourceBuffer) if (!SourceBuffer)
return nullptr; return nullptr;
auto Branches = FunctionCoverage.getBranches(); auto Branches = FunctionCoverage.getBranches();
auto Expansions = FunctionCoverage.getExpansions(); auto Expansions = FunctionCoverage.getExpansions();
auto MCDCRecords = FunctionCoverage.getMCDCRecords();
auto View = SourceCoverageView::create(DC.demangle(Function.Name), auto View = SourceCoverageView::create(DC.demangle(Function.Name),
SourceBuffer.get(), ViewOpts, SourceBuffer.get(), ViewOpts,
std::move(FunctionCoverage)); std::move(FunctionCoverage));
attachExpansionSubViews(*View, Expansions, Coverage); attachExpansionSubViews(*View, Expansions, Coverage);
attachBranchSubViews(*View, DC.demangle(Function.Name), Branches, attachBranchSubViews(*View, DC.demangle(Function.Name), Branches,
SourceBuffer.get(), FunctionCoverage); SourceBuffer.get(), FunctionCoverage);
attachMCDCSubViews(*View, DC.demangle(Function.Name), MCDCRecords,
SourceBuffer.get(), FunctionCoverage);
return View; return View;
} }
std::unique_ptr<SourceCoverageView> std::unique_ptr<SourceCoverageView>
CodeCoverageTool::createSourceFileView(StringRef SourceFile, CodeCoverageTool::createSourceFileView(StringRef SourceFile,
const CoverageMapping &Coverage) { const CoverageMapping &Coverage) {
auto SourceBuffer = getSourceFile(SourceFile); auto SourceBuffer = getSourceFile(SourceFile);
if (!SourceBuffer) if (!SourceBuffer)
return nullptr; return nullptr;
auto FileCoverage = Coverage.getCoverageForFile(SourceFile); auto FileCoverage = Coverage.getCoverageForFile(SourceFile);
if (FileCoverage.empty()) if (FileCoverage.empty())
return nullptr; return nullptr;
auto Branches = FileCoverage.getBranches(); auto Branches = FileCoverage.getBranches();
auto Expansions = FileCoverage.getExpansions(); auto Expansions = FileCoverage.getExpansions();
auto MCDCRecords = FileCoverage.getMCDCRecords();
auto View = SourceCoverageView::create(SourceFile, SourceBuffer.get(), auto View = SourceCoverageView::create(SourceFile, SourceBuffer.get(),
ViewOpts, std::move(FileCoverage)); ViewOpts, std::move(FileCoverage));
attachExpansionSubViews(*View, Expansions, Coverage); attachExpansionSubViews(*View, Expansions, Coverage);
attachBranchSubViews(*View, SourceFile, Branches, SourceBuffer.get(), attachBranchSubViews(*View, SourceFile, Branches, SourceBuffer.get(),
FileCoverage); FileCoverage);
attachMCDCSubViews(*View, SourceFile, MCDCRecords, SourceBuffer.get(),
FileCoverage);
if (!ViewOpts.ShowFunctionInstantiations) if (!ViewOpts.ShowFunctionInstantiations)
return View; return View;
for (const auto &Group : Coverage.getInstantiationGroups(SourceFile)) { for (const auto &Group : Coverage.getInstantiationGroups(SourceFile)) {
// Skip functions which have a single instantiation. // Skip functions which have a single instantiation.
if (Group.size() < 2) if (Group.size() < 2)
continue; continue;
for (const FunctionRecord *Function : Group.getInstantiations()) { for (const FunctionRecord *Function : Group.getInstantiations()) {
std::unique_ptr<SourceCoverageView> SubView{nullptr}; std::unique_ptr<SourceCoverageView> SubView{nullptr};
StringRef Funcname = DC.demangle(Function->Name); StringRef Funcname = DC.demangle(Function->Name);
if (Function->ExecutionCount > 0) { if (Function->ExecutionCount > 0) {
auto SubViewCoverage = Coverage.getCoverageForFunction(*Function); auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
auto SubViewExpansions = SubViewCoverage.getExpansions(); auto SubViewExpansions = SubViewCoverage.getExpansions();
auto SubViewBranches = SubViewCoverage.getBranches(); auto SubViewBranches = SubViewCoverage.getBranches();
auto SubViewMCDCRecords = SubViewCoverage.getMCDCRecords();
SubView = SourceCoverageView::create( SubView = SourceCoverageView::create(
Funcname, SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage)); Funcname, SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage));
attachExpansionSubViews(*SubView, SubViewExpansions, Coverage); attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
attachBranchSubViews(*SubView, SourceFile, SubViewBranches, attachBranchSubViews(*SubView, SourceFile, SubViewBranches,
SourceBuffer.get(), SubViewCoverage); SourceBuffer.get(), SubViewCoverage);
attachMCDCSubViews(*SubView, SourceFile, SubViewMCDCRecords,
SourceBuffer.get(), SubViewCoverage);
} }
unsigned FileID = Function->CountedRegions.front().FileID; unsigned FileID = Function->CountedRegions.front().FileID;
unsigned Line = 0; unsigned Line = 0;
for (const auto &CR : Function->CountedRegions) for (const auto &CR : Function->CountedRegions)
if (CR.FileID == FileID) if (CR.FileID == FileID)
Line = std::max(CR.LineEnd, Line); Line = std::max(CR.LineEnd, Line);
View->addInstantiation(Funcname, Line, std::move(SubView)); View->addInstantiation(Funcname, Line, std::move(SubView));
▲ Show 20 Lines • Show All 305 Lines • ▼ Show 20 Lines cl::opt<bool> RegionSummary(
cl::desc("Show region statistics in summary table"), cl::desc("Show region statistics in summary table"),
cl::init(true)); cl::init(true));
cl::opt<bool> BranchSummary( cl::opt<bool> BranchSummary(
"show-branch-summary", cl::Optional, "show-branch-summary", cl::Optional,
cl::desc("Show branch condition statistics in summary table"), cl::desc("Show branch condition statistics in summary table"),
cl::init(true)); cl::init(true));
cl::opt<bool> MCDCSummary(
"show-mcdc-summary", cl::Optional,
cl::desc("Show MCDC statistics in summary table"),
cl::init(false));
cl::opt<bool> InstantiationSummary( cl::opt<bool> InstantiationSummary(
"show-instantiation-summary", cl::Optional, "show-instantiation-summary", cl::Optional,
cl::desc("Show instantiation statistics in summary table")); cl::desc("Show instantiation statistics in summary table"));
cl::opt<bool> SummaryOnly( cl::opt<bool> SummaryOnly(
"summary-only", cl::Optional, "summary-only", cl::Optional,
cl::desc("Export only summary information for each source file")); cl::desc("Export only summary information for each source file"));
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines for (const std::string &File : InputSourceFiles)
collectPaths(File); collectPaths(File);
if (DebugDumpCollectedPaths) { if (DebugDumpCollectedPaths) {
for (const std::string &SF : SourceFiles) for (const std::string &SF : SourceFiles)
outs() << SF << '\n'; outs() << SF << '\n';
::exit(0); ::exit(0);
} }
ViewOpts.ShowMCDCSummary = MCDCSummary;
ViewOpts.ShowBranchSummary = BranchSummary; ViewOpts.ShowBranchSummary = BranchSummary;
ViewOpts.ShowRegionSummary = RegionSummary; ViewOpts.ShowRegionSummary = RegionSummary;
ViewOpts.ShowInstantiationSummary = InstantiationSummary; ViewOpts.ShowInstantiationSummary = InstantiationSummary;
ViewOpts.ExportSummaryOnly = SummaryOnly; ViewOpts.ExportSummaryOnly = SummaryOnly;
ViewOpts.NumThreads = NumThreads; ViewOpts.NumThreads = NumThreads;
ViewOpts.CompilationDirectory = CompilationDirectory; ViewOpts.CompilationDirectory = CompilationDirectory;
return 0; return 0;
Show All 29 Lines cl::opt<CoverageViewOptions::BranchOutputType> ShowBranches(
"show-branches", cl::Optional, "show-branches", cl::Optional,
cl::desc("Show coverage for branch conditions"), cl::cat(ViewCategory), cl::desc("Show coverage for branch conditions"), cl::cat(ViewCategory),
cl::values(clEnumValN(CoverageViewOptions::BranchOutputType::Count, cl::values(clEnumValN(CoverageViewOptions::BranchOutputType::Count,
"count", "Show True/False counts"), "count", "Show True/False counts"),
clEnumValN(CoverageViewOptions::BranchOutputType::Percent, clEnumValN(CoverageViewOptions::BranchOutputType::Percent,
"percent", "Show True/False percent")), "percent", "Show True/False percent")),
cl::init(CoverageViewOptions::BranchOutputType::Off)); cl::init(CoverageViewOptions::BranchOutputType::Off));
cl::opt<bool> ShowMCDC(
"show-mcdc", cl::Optional,
cl::desc("Show the MCDC Coverage for each applicable boolean expression"),
cl::cat(ViewCategory));
cl::opt<bool> ShowBestLineRegionsCounts( cl::opt<bool> ShowBestLineRegionsCounts(
"show-line-counts-or-regions", cl::Optional, "show-line-counts-or-regions", cl::Optional,
cl::desc("Show the execution counts for each line, or the execution " cl::desc("Show the execution counts for each line, or the execution "
"counts for each region on lines that have multiple regions"), "counts for each region on lines that have multiple regions"),
cl::cat(ViewCategory)); cl::cat(ViewCategory));
cl::opt<bool> ShowExpansions("show-expansions", cl::Optional, cl::opt<bool> ShowExpansions("show-expansions", cl::Optional,
cl::desc("Show expanded source regions"), cl::desc("Show expanded source regions"),
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Linesint CodeCoverageTool::doShow(int argc, const char **argv,
ViewOpts.ShowLineNumbers = true; ViewOpts.ShowLineNumbers = true;
ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 || ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
!ShowRegions || ShowBestLineRegionsCounts; !ShowRegions || ShowBestLineRegionsCounts;
ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts; ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
ViewOpts.ShowExpandedRegions = ShowExpansions; ViewOpts.ShowExpandedRegions = ShowExpansions;
ViewOpts.ShowBranchCounts = ViewOpts.ShowBranchCounts =
ShowBranches == CoverageViewOptions::BranchOutputType::Count; ShowBranches == CoverageViewOptions::BranchOutputType::Count;
ViewOpts.ShowMCDC = ShowMCDC;
ViewOpts.ShowBranchPercents = ViewOpts.ShowBranchPercents =
ShowBranches == CoverageViewOptions::BranchOutputType::Percent; ShowBranches == CoverageViewOptions::BranchOutputType::Percent;
ViewOpts.ShowFunctionInstantiations = ShowInstantiations; ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
ViewOpts.ShowOutputDirectory = ShowOutputDirectory; ViewOpts.ShowOutputDirectory = ShowOutputDirectory;
ViewOpts.TabSize = TabSize; ViewOpts.TabSize = TabSize;
ViewOpts.ProjectTitle = ProjectTitle; ViewOpts.ProjectTitle = ProjectTitle;
if (ViewOpts.hasOutputDirectory()) { if (ViewOpts.hasOutputDirectory()) {
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

llvm/tools/llvm-cov/CoverageExporterJson.cpp

Show All 14 Lines
// The json code coverage export follows the following format // The json code coverage export follows the following format
// Root: dict => Root Element containing metadata // Root: dict => Root Element containing metadata
// -- Data: array => Homogeneous array of one or more export objects // -- Data: array => Homogeneous array of one or more export objects
// -- Export: dict => Json representation of one CoverageMapping // -- Export: dict => Json representation of one CoverageMapping
// -- Files: array => List of objects describing coverage for files // -- Files: array => List of objects describing coverage for files
// -- File: dict => Coverage for a single file // -- File: dict => Coverage for a single file
// -- Branches: array => List of Branches in the file // -- Branches: array => List of Branches in the file
// -- Branch: dict => Describes a branch of the file with counters // -- Branch: dict => Describes a branch of the file with counters
// -- MCDC Records: array => List of MCDC records in the file
// -- MCDC Values: array => List of T/F covered condition values
// -- Segments: array => List of Segments contained in the file // -- Segments: array => List of Segments contained in the file
// -- Segment: dict => Describes a segment of the file with a counter // -- Segment: dict => Describes a segment of the file with a counter
// -- Expansions: array => List of expansion records // -- Expansions: array => List of expansion records
// -- Expansion: dict => Object that descibes a single expansion // -- Expansion: dict => Object that descibes a single expansion
// -- CountedRegion: dict => The region to be expanded // -- CountedRegion: dict => The region to be expanded
// -- TargetRegions: array => List of Regions in the expansion // -- TargetRegions: array => List of Regions in the expansion
// -- CountedRegion: dict => Single Region in the expansion // -- CountedRegion: dict => Single Region in the expansion
// -- Branches: array => List of Branches in the expansion // -- Branches: array => List of Branches in the expansion
// -- Branch: dict => Describes a branch in expansion and counters // -- Branch: dict => Describes a branch in expansion and counters
// -- Summary: dict => Object summarizing the coverage for this file // -- Summary: dict => Object summarizing the coverage for this file
// -- LineCoverage: dict => Object summarizing line coverage // -- LineCoverage: dict => Object summarizing line coverage
// -- FunctionCoverage: dict => Object summarizing function coverage // -- FunctionCoverage: dict => Object summarizing function coverage
// -- RegionCoverage: dict => Object summarizing region coverage // -- RegionCoverage: dict => Object summarizing region coverage
// -- BranchCoverage: dict => Object summarizing branch coverage // -- BranchCoverage: dict => Object summarizing branch coverage
// -- MCDCCoverage: dict => Object summarizing MC/DC coverage
// -- Functions: array => List of objects describing coverage for functions // -- Functions: array => List of objects describing coverage for functions
// -- Function: dict => Coverage info for a single function // -- Function: dict => Coverage info for a single function
// -- Filenames: array => List of filenames that the function relates to // -- Filenames: array => List of filenames that the function relates to
// -- Summary: dict => Object summarizing the coverage for the entire binary // -- Summary: dict => Object summarizing the coverage for the entire binary
// -- LineCoverage: dict => Object summarizing line coverage // -- LineCoverage: dict => Object summarizing line coverage
// -- FunctionCoverage: dict => Object summarizing function coverage // -- FunctionCoverage: dict => Object summarizing function coverage
// -- InstantiationCoverage: dict => Object summarizing inst. coverage // -- InstantiationCoverage: dict => Object summarizing inst. coverage
// -- RegionCoverage: dict => Object summarizing region coverage // -- RegionCoverage: dict => Object summarizing region coverage
// -- BranchCoverage: dict => Object summarizing branch coverage // -- BranchCoverage: dict => Object summarizing branch coverage
// -- MCDCCoverage: dict => Object summarizing MC/DC coverage
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CoverageExporterJson.h" #include "CoverageExporterJson.h"
#include "CoverageReport.h" #include "CoverageReport.h"
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/JSON.h" #include "llvm/Support/JSON.h"
Show All 39 Lines
json::Array renderBranch(const coverage::CountedRegion &Region) { json::Array renderBranch(const coverage::CountedRegion &Region) {
return json::Array( return json::Array(
{Region.LineStart, Region.ColumnStart, Region.LineEnd, Region.ColumnEnd, {Region.LineStart, Region.ColumnStart, Region.LineEnd, Region.ColumnEnd,
clamp_uint64_to_int64(Region.ExecutionCount), clamp_uint64_to_int64(Region.ExecutionCount),
clamp_uint64_to_int64(Region.FalseExecutionCount), Region.FileID, clamp_uint64_to_int64(Region.FalseExecutionCount), Region.FileID,
Region.ExpandedFileID, int64_t(Region.Kind)}); Region.ExpandedFileID, int64_t(Region.Kind)});
} }
json::Array gatherConditions(const coverage::MCDCRecord &Record) {
json::Array Conditions;
for (unsigned c = 0; c < Record.getNumConditions(); c++)
Conditions.push_back(Record.isCondIndepPairCovered(c));
return Conditions;
}
json::Array renderMCDCRecord(const coverage::MCDCRecord &Record) {
const llvm::coverage::CounterMappingRegion &CMR = Record.getDecisionRegion();
return json::Array({CMR.LineStart, CMR.ColumnStart, CMR.LineEnd,
CMR.ColumnEnd, CMR.ExpandedFileID, int64_t(CMR.Kind),
gatherConditions(Record)});
}
json::Array renderRegions(ArrayRef<coverage::CountedRegion> Regions) { json::Array renderRegions(ArrayRef<coverage::CountedRegion> Regions) {
json::Array RegionArray; json::Array RegionArray;
for (const auto &Region : Regions) for (const auto &Region : Regions)
RegionArray.push_back(renderRegion(Region)); RegionArray.push_back(renderRegion(Region));
return RegionArray; return RegionArray;
} }
json::Array renderBranchRegions(ArrayRef<coverage::CountedRegion> Regions) { json::Array renderBranchRegions(ArrayRef<coverage::CountedRegion> Regions) {
json::Array RegionArray; json::Array RegionArray;
for (const auto &Region : Regions) for (const auto &Region : Regions)
if (!Region.Folded) if (!Region.Folded)
RegionArray.push_back(renderBranch(Region)); RegionArray.push_back(renderBranch(Region));
return RegionArray; return RegionArray;
} }
json::Array renderMCDCRecords(ArrayRef<coverage::MCDCRecord> Records) {
json::Array RecordArray;
for (auto &Record : Records)
RecordArray.push_back(renderMCDCRecord(Record));
return RecordArray;
}
std::vector<llvm::coverage::CountedRegion> std::vector<llvm::coverage::CountedRegion>
collectNestedBranches(const coverage::CoverageMapping &Coverage, collectNestedBranches(const coverage::CoverageMapping &Coverage,
ArrayRef<llvm::coverage::ExpansionRecord> Expansions) { ArrayRef<llvm::coverage::ExpansionRecord> Expansions) {
std::vector<llvm::coverage::CountedRegion> Branches; std::vector<llvm::coverage::CountedRegion> Branches;
for (const auto &Expansion : Expansions) { for (const auto &Expansion : Expansions) {
auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion); auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
// Recursively collect branches from nested expansions. // Recursively collect branches from nested expansions.
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines return json::Object(
Summary.RegionCoverage.getCovered())}, Summary.RegionCoverage.getCovered())},
{"percent", Summary.RegionCoverage.getPercentCovered()}})}, {"percent", Summary.RegionCoverage.getPercentCovered()}})},
{"branches", {"branches",
json::Object( json::Object(
{{"count", int64_t(Summary.BranchCoverage.getNumBranches())}, {{"count", int64_t(Summary.BranchCoverage.getNumBranches())},
{"covered", int64_t(Summary.BranchCoverage.getCovered())}, {"covered", int64_t(Summary.BranchCoverage.getCovered())},
{"notcovered", int64_t(Summary.BranchCoverage.getNumBranches() - {"notcovered", int64_t(Summary.BranchCoverage.getNumBranches() -
Summary.BranchCoverage.getCovered())}, Summary.BranchCoverage.getCovered())},
{"percent", Summary.BranchCoverage.getPercentCovered()}})}}); {"percent", Summary.BranchCoverage.getPercentCovered()}})},
{"mcdc",
json::Object(
{{"count", int64_t(Summary.MCDCCoverage.getNumPairs())},
{"covered", int64_t(Summary.MCDCCoverage.getCoveredPairs())},
{"notcovered", int64_t(Summary.MCDCCoverage.getNumPairs() -
Summary.MCDCCoverage.getCoveredPairs())},
{"percent", Summary.MCDCCoverage.getPercentCovered()}})}});
} }
json::Array renderFileExpansions(const coverage::CoverageMapping &Coverage, json::Array renderFileExpansions(const coverage::CoverageMapping &Coverage,
const coverage::CoverageData &FileCoverage, const coverage::CoverageData &FileCoverage,
const FileCoverageSummary &FileReport) { const FileCoverageSummary &FileReport) {
json::Array ExpansionArray; json::Array ExpansionArray;
for (const auto &Expansion : FileCoverage.getExpansions()) for (const auto &Expansion : FileCoverage.getExpansions())
ExpansionArray.push_back(renderExpansion(Coverage, Expansion)); ExpansionArray.push_back(renderExpansion(Coverage, Expansion));
Show All 11 Lines
json::Array renderFileBranches(const coverage::CoverageData &FileCoverage, json::Array renderFileBranches(const coverage::CoverageData &FileCoverage,
const FileCoverageSummary &FileReport) { const FileCoverageSummary &FileReport) {
json::Array BranchArray; json::Array BranchArray;
for (const auto &Branch : FileCoverage.getBranches()) for (const auto &Branch : FileCoverage.getBranches())
BranchArray.push_back(renderBranch(Branch)); BranchArray.push_back(renderBranch(Branch));
return BranchArray; return BranchArray;
} }
json::Array renderFileMCDC(const coverage::CoverageData &FileCoverage,
const FileCoverageSummary &FileReport) {
json::Array MCDCRecordArray;
for (const auto &Record : FileCoverage.getMCDCRecords())
MCDCRecordArray.push_back(renderMCDCRecord(Record));
return MCDCRecordArray;
}
json::Object renderFile(const coverage::CoverageMapping &Coverage, json::Object renderFile(const coverage::CoverageMapping &Coverage,
const std::string &Filename, const std::string &Filename,
const FileCoverageSummary &FileReport, const FileCoverageSummary &FileReport,
const CoverageViewOptions &Options) { const CoverageViewOptions &Options) {
json::Object File({{"filename", Filename}}); json::Object File({{"filename", Filename}});
if (!Options.ExportSummaryOnly) { if (!Options.ExportSummaryOnly) {
// Calculate and render detailed coverage information for given file. // Calculate and render detailed coverage information for given file.
auto FileCoverage = Coverage.getCoverageForFile(Filename); auto FileCoverage = Coverage.getCoverageForFile(Filename);
File["segments"] = renderFileSegments(FileCoverage, FileReport); File["segments"] = renderFileSegments(FileCoverage, FileReport);
File["branches"] = renderFileBranches(FileCoverage, FileReport); File["branches"] = renderFileBranches(FileCoverage, FileReport);
File["mcdc_records"] = renderFileMCDC(FileCoverage, FileReport);
if (!Options.SkipExpansions) { if (!Options.SkipExpansions) {
File["expansions"] = File["expansions"] =
renderFileExpansions(Coverage, FileCoverage, FileReport); renderFileExpansions(Coverage, FileCoverage, FileReport);
} }
} }
File["summary"] = renderSummary(FileReport); File["summary"] = renderSummary(FileReport);
return File; return File;
} }
Show All 32 Linesjson::Array renderFunctions(
const iterator_range<coverage::FunctionRecordIterator> &Functions) { const iterator_range<coverage::FunctionRecordIterator> &Functions) {
json::Array FunctionArray; json::Array FunctionArray;
for (const auto &F : Functions) for (const auto &F : Functions)
FunctionArray.push_back( FunctionArray.push_back(
json::Object({{"name", F.Name}, json::Object({{"name", F.Name},
{"count", clamp_uint64_to_int64(F.ExecutionCount)}, {"count", clamp_uint64_to_int64(F.ExecutionCount)},
{"regions", renderRegions(F.CountedRegions)}, {"regions", renderRegions(F.CountedRegions)},
{"branches", renderBranchRegions(F.CountedBranchRegions)}, {"branches", renderBranchRegions(F.CountedBranchRegions)},
{"mcdc_records", renderMCDCRecords(F.MCDCRecords)},
{"filenames", json::Array(F.Filenames)}})); {"filenames", json::Array(F.Filenames)}}));
return FunctionArray; return FunctionArray;
} }
} // end anonymous namespace } // end anonymous namespace
void CoverageExporterJson::renderRoot(const CoverageFilters &IgnoreFilters) { void CoverageExporterJson::renderRoot(const CoverageFilters &IgnoreFilters) {
std::vector<std::string> SourceFiles; std::vector<std::string> SourceFiles;
Show All 34 Lines

llvm/tools/llvm-cov/CoverageReport.cpp

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
Column column(StringRef Str, unsigned Width) { return Column(Str, Width); } Column column(StringRef Str, unsigned Width) { return Column(Str, Width); }
template <typename T> template <typename T>
Column column(StringRef Str, unsigned Width, const T &Value) { Column column(StringRef Str, unsigned Width, const T &Value) {
return Column(Str, Width).set(Value); return Column(Str, Width).set(Value);
} }
// Specify the default column widths. // Specify the default column widths.
size_t FileReportColumns[] = {25, 12, 18, 10, 12, 18, 10, 16, size_t FileReportColumns[] = {25, 12, 18, 10, 12, 18, 10, 16, 16, 10,
16, 10, 12, 18, 10, 12, 18, 10}; 12, 18, 10, 12, 18, 10, 20, 21, 10};
size_t FunctionReportColumns[] = {25, 10, 8, 8, 10, 8, 8, 10, 8, 8}; size_t FunctionReportColumns[] = {25, 10, 8, 8, 10, 8, 8, 10, 8, 8, 20, 8, 8};
/// Adjust column widths to fit long file paths and function names. /// Adjust column widths to fit long file paths and function names.
void adjustColumnWidths(ArrayRef<StringRef> Files, void adjustColumnWidths(ArrayRef<StringRef> Files,
ArrayRef<StringRef> Functions) { ArrayRef<StringRef> Functions) {
for (StringRef Filename : Files) for (StringRef Filename : Files)
FileReportColumns[0] = std::max(FileReportColumns[0], Filename.size()); FileReportColumns[0] = std::max(FileReportColumns[0], Filename.size());
for (StringRef Funcname : Functions) for (StringRef Funcname : Functions)
FunctionReportColumns[0] = FunctionReportColumns[0] =
▲ Show 20 Lines • Show All 151 Lines • ▼ Show 20 Lines if (File.BranchCoverage.getNumBranches())
Options.colored_ostream(OS, LineCoverageColor) Options.colored_ostream(OS, LineCoverageColor)
<< format("%*.2f", FileReportColumns[15] - 1, << format("%*.2f", FileReportColumns[15] - 1,
File.BranchCoverage.getPercentCovered()) File.BranchCoverage.getPercentCovered())
<< '%'; << '%';
else else
OS << column("-", FileReportColumns[15], Column::RightAlignment); OS << column("-", FileReportColumns[15], Column::RightAlignment);
} }
if (Options.ShowMCDCSummary) {
OS << format("%*u", FileReportColumns[16],
(unsigned)File.MCDCCoverage.getNumPairs());
Options.colored_ostream(OS, LineCoverageColor)
<< format("%*u", FileReportColumns[17],
(unsigned)(File.MCDCCoverage.getNumPairs() -
File.MCDCCoverage.getCoveredPairs()));
if (File.MCDCCoverage.getNumPairs())
Options.colored_ostream(OS, LineCoverageColor)
<< format("%*.2f", FileReportColumns[18] - 1,
File.MCDCCoverage.getPercentCovered())
<< '%';
else
OS << column("-", FileReportColumns[18], Column::RightAlignment);
}
OS << "\n"; OS << "\n";
} }
void CoverageReport::render(const FunctionCoverageSummary &Function, void CoverageReport::render(const FunctionCoverageSummary &Function,
const DemangleCache &DC, const DemangleCache &DC,
raw_ostream &OS) const { raw_ostream &OS) const {
auto FuncCoverageColor = auto FuncCoverageColor =
determineCoveragePercentageColor(Function.RegionCoverage); determineCoveragePercentageColor(Function.RegionCoverage);
Show All 31 Lines Options.colored_ostream(OS, LineCoverageColor)
(unsigned)(Function.BranchCoverage.getNumBranches() - (unsigned)(Function.BranchCoverage.getNumBranches() -
Function.BranchCoverage.getCovered())); Function.BranchCoverage.getCovered()));
Options.colored_ostream( Options.colored_ostream(
OS, determineCoveragePercentageColor(Function.BranchCoverage)) OS, determineCoveragePercentageColor(Function.BranchCoverage))
<< format("%*.2f", FunctionReportColumns[9] - 1, << format("%*.2f", FunctionReportColumns[9] - 1,
Function.BranchCoverage.getPercentCovered()) Function.BranchCoverage.getPercentCovered())
<< '%'; << '%';
} }
if (Options.ShowMCDCSummary) {
OS << format("%*u", FunctionReportColumns[10],
(unsigned)Function.MCDCCoverage.getNumPairs());
Options.colored_ostream(OS, LineCoverageColor)
<< format("%*u", FunctionReportColumns[11],
(unsigned)(Function.MCDCCoverage.getNumPairs() -
Function.MCDCCoverage.getCoveredPairs()));
Options.colored_ostream(
OS, determineCoveragePercentageColor(Function.MCDCCoverage))
<< format("%*.2f", FunctionReportColumns[12] - 1,
Function.MCDCCoverage.getPercentCovered())
<< '%';
}
OS << "\n"; OS << "\n";
} }
void CoverageReport::renderFunctionReports(ArrayRef<std::string> Files, void CoverageReport::renderFunctionReports(ArrayRef<std::string> Files,
const DemangleCache &DC, const DemangleCache &DC,
raw_ostream &OS) { raw_ostream &OS) {
bool isFirst = true; bool isFirst = true;
for (StringRef Filename : Files) { for (StringRef Filename : Files) {
Show All 16 Lines OS << column("Name", FunctionReportColumns[0])
<< column("Cover", FunctionReportColumns[3], Column::RightAlignment) << column("Cover", FunctionReportColumns[3], Column::RightAlignment)
<< column("Lines", FunctionReportColumns[4], Column::RightAlignment) << column("Lines", FunctionReportColumns[4], Column::RightAlignment)
<< column("Miss", FunctionReportColumns[5], Column::RightAlignment) << column("Miss", FunctionReportColumns[5], Column::RightAlignment)
<< column("Cover", FunctionReportColumns[6], Column::RightAlignment); << column("Cover", FunctionReportColumns[6], Column::RightAlignment);
if (Options.ShowBranchSummary) if (Options.ShowBranchSummary)
OS << column("Branches", FunctionReportColumns[7], Column::RightAlignment) OS << column("Branches", FunctionReportColumns[7], Column::RightAlignment)
<< column("Miss", FunctionReportColumns[8], Column::RightAlignment) << column("Miss", FunctionReportColumns[8], Column::RightAlignment)
<< column("Cover", FunctionReportColumns[9], Column::RightAlignment); << column("Cover", FunctionReportColumns[9], Column::RightAlignment);
if (Options.ShowMCDCSummary)
OS << column("MC/DC Conditions", FunctionReportColumns[10],
Column::RightAlignment)
<< column("Miss", FunctionReportColumns[11], Column::RightAlignment)
<< column("Cover", FunctionReportColumns[12], Column::RightAlignment);
OS << "\n"; OS << "\n";
renderDivider(FunctionReportColumns, OS); renderDivider(FunctionReportColumns, OS);
OS << "\n"; OS << "\n";
FunctionCoverageSummary Totals("TOTAL"); FunctionCoverageSummary Totals("TOTAL");
for (const auto &F : Functions) { for (const auto &F : Functions) {
auto Function = FunctionCoverageSummary::get(Coverage, F); auto Function = FunctionCoverageSummary::get(Coverage, F);
++Totals.ExecutionCount; ++Totals.ExecutionCount;
Totals.RegionCoverage += Function.RegionCoverage; Totals.RegionCoverage += Function.RegionCoverage;
Totals.LineCoverage += Function.LineCoverage; Totals.LineCoverage += Function.LineCoverage;
Totals.BranchCoverage += Function.BranchCoverage; Totals.BranchCoverage += Function.BranchCoverage;
Totals.MCDCCoverage += Function.MCDCCoverage;
render(Function, DC, OS); render(Function, DC, OS);
} }
if (Totals.ExecutionCount) { if (Totals.ExecutionCount) {
renderDivider(FunctionReportColumns, OS); renderDivider(FunctionReportColumns, OS);
OS << "\n"; OS << "\n";
render(Totals, DC, OS); render(Totals, DC, OS);
} }
} }
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Linesvoid CoverageReport::renderFileReports(
OS << column("Lines", FileReportColumns[10], Column::RightAlignment) OS << column("Lines", FileReportColumns[10], Column::RightAlignment)
<< column("Missed Lines", FileReportColumns[11], Column::RightAlignment) << column("Missed Lines", FileReportColumns[11], Column::RightAlignment)
<< column("Cover", FileReportColumns[12], Column::RightAlignment); << column("Cover", FileReportColumns[12], Column::RightAlignment);
if (Options.ShowBranchSummary) if (Options.ShowBranchSummary)
OS << column("Branches", FileReportColumns[13], Column::RightAlignment) OS << column("Branches", FileReportColumns[13], Column::RightAlignment)
<< column("Missed Branches", FileReportColumns[14], << column("Missed Branches", FileReportColumns[14],
Column::RightAlignment) Column::RightAlignment)
<< column("Cover", FileReportColumns[15], Column::RightAlignment); << column("Cover", FileReportColumns[15], Column::RightAlignment);
if (Options.ShowMCDCSummary)
OS << column("MC/DC Conditions", FileReportColumns[16],
Column::RightAlignment)
<< column("Missed Conditions", FileReportColumns[17],
Column::RightAlignment)
<< column("Cover", FileReportColumns[18], Column::RightAlignment);
OS << "\n"; OS << "\n";
renderDivider(FileReportColumns, OS); renderDivider(FileReportColumns, OS);
OS << "\n"; OS << "\n";
bool EmptyFiles = false; bool EmptyFiles = false;
for (const FileCoverageSummary &FCS : FileReports) { for (const FileCoverageSummary &FCS : FileReports) {
if (FCS.FunctionCoverage.getNumFunctions()) if (FCS.FunctionCoverage.getNumFunctions())
render(FCS, OS); render(FCS, OS);
Show All 19 Lines

llvm/tools/llvm-cov/CoverageSummaryInfo.h

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Linespublic:
double getPercentCovered() const { double getPercentCovered() const {
assert(Covered <= NumBranches && "Covered branches over-counted"); assert(Covered <= NumBranches && "Covered branches over-counted");
if (NumBranches == 0) if (NumBranches == 0)
return 0.0; return 0.0;
return double(Covered) / double(NumBranches) * 100.0; return double(Covered) / double(NumBranches) * 100.0;
} }
}; };
/// Provides information about branches coverage for a function/file.
class MCDCCoverageInfo {
/// The number of Independence Pairs that were covered
size_t CoveredPairs;
/// The total number of Independence Pairs in a function/file.
size_t NumPairs;
public:
MCDCCoverageInfo() : CoveredPairs(0), NumPairs(0) {}
MCDCCoverageInfo(size_t CoveredPairs, size_t NumPairs)
: CoveredPairs(CoveredPairs), NumPairs(NumPairs) {
assert(CoveredPairs <= NumPairs && "Covered Pairs over-counted");
}
MCDCCoverageInfo &operator+=(const MCDCCoverageInfo &RHS) {
CoveredPairs += RHS.CoveredPairs;
NumPairs += RHS.NumPairs;
return *this;
}
void merge(const MCDCCoverageInfo &RHS) {
CoveredPairs = std::max(CoveredPairs, RHS.CoveredPairs);
NumPairs = std::max(NumPairs, RHS.NumPairs);
}
size_t getCoveredPairs() const { return CoveredPairs; }
size_t getNumPairs() const { return NumPairs; }
bool isFullyCovered() const { return CoveredPairs == NumPairs; }
double getPercentCovered() const {
assert(CoveredPairs <= NumPairs && "Covered Pairs over-counted");
if (NumPairs == 0)
return 0.0;
return double(CoveredPairs) / double(NumPairs) * 100.0;
}
};
/// Provides information about function coverage for a file. /// Provides information about function coverage for a file.
class FunctionCoverageInfo { class FunctionCoverageInfo {
/// The number of functions that were executed. /// The number of functions that were executed.
size_t Executed; size_t Executed;
/// The total number of functions in this file. /// The total number of functions in this file.
size_t NumFunctions; size_t NumFunctions;
Show All 31 Lines
/// A summary of function's code coverage. /// A summary of function's code coverage.
struct FunctionCoverageSummary { struct FunctionCoverageSummary {
std::string Name; std::string Name;
uint64_t ExecutionCount; uint64_t ExecutionCount;
RegionCoverageInfo RegionCoverage; RegionCoverageInfo RegionCoverage;
LineCoverageInfo LineCoverage; LineCoverageInfo LineCoverage;
BranchCoverageInfo BranchCoverage; BranchCoverageInfo BranchCoverage;
MCDCCoverageInfo MCDCCoverage;
FunctionCoverageSummary(const std::string &Name) FunctionCoverageSummary(const std::string &Name)
: Name(Name), ExecutionCount(0) {} : Name(Name), ExecutionCount(0) {}
FunctionCoverageSummary(const std::string &Name, uint64_t ExecutionCount, FunctionCoverageSummary(const std::string &Name, uint64_t ExecutionCount,
const RegionCoverageInfo &RegionCoverage, const RegionCoverageInfo &RegionCoverage,
const LineCoverageInfo &LineCoverage, const LineCoverageInfo &LineCoverage,
const BranchCoverageInfo &BranchCoverage) const BranchCoverageInfo &BranchCoverage,
const MCDCCoverageInfo &MCDCCoverage)
: Name(Name), ExecutionCount(ExecutionCount), : Name(Name), ExecutionCount(ExecutionCount),
RegionCoverage(RegionCoverage), LineCoverage(LineCoverage), RegionCoverage(RegionCoverage), LineCoverage(LineCoverage),
BranchCoverage(BranchCoverage) {} BranchCoverage(BranchCoverage), MCDCCoverage(MCDCCoverage) {}
/// Compute the code coverage summary for the given function coverage /// Compute the code coverage summary for the given function coverage
/// mapping record. /// mapping record.
static FunctionCoverageSummary get(const coverage::CoverageMapping &CM, static FunctionCoverageSummary get(const coverage::CoverageMapping &CM,
const coverage::FunctionRecord &Function); const coverage::FunctionRecord &Function);
/// Compute the code coverage summary for an instantiation group \p Group, /// Compute the code coverage summary for an instantiation group \p Group,
/// given a list of summaries for each instantiation in \p Summaries. /// given a list of summaries for each instantiation in \p Summaries.
static FunctionCoverageSummary static FunctionCoverageSummary
get(const coverage::InstantiationGroup &Group, get(const coverage::InstantiationGroup &Group,
ArrayRef<FunctionCoverageSummary> Summaries); ArrayRef<FunctionCoverageSummary> Summaries);
}; };
/// A summary of file's code coverage. /// A summary of file's code coverage.
struct FileCoverageSummary { struct FileCoverageSummary {
StringRef Name; StringRef Name;
RegionCoverageInfo RegionCoverage; RegionCoverageInfo RegionCoverage;
LineCoverageInfo LineCoverage; LineCoverageInfo LineCoverage;
BranchCoverageInfo BranchCoverage; BranchCoverageInfo BranchCoverage;
MCDCCoverageInfo MCDCCoverage;
FunctionCoverageInfo FunctionCoverage; FunctionCoverageInfo FunctionCoverage;
FunctionCoverageInfo InstantiationCoverage; FunctionCoverageInfo InstantiationCoverage;
FileCoverageSummary(StringRef Name) : Name(Name) {} FileCoverageSummary(StringRef Name) : Name(Name) {}
FileCoverageSummary &operator+=(const FileCoverageSummary &RHS) { FileCoverageSummary &operator+=(const FileCoverageSummary &RHS) {
RegionCoverage += RHS.RegionCoverage; RegionCoverage += RHS.RegionCoverage;
LineCoverage += RHS.LineCoverage; LineCoverage += RHS.LineCoverage;
FunctionCoverage += RHS.FunctionCoverage; FunctionCoverage += RHS.FunctionCoverage;
BranchCoverage += RHS.BranchCoverage; BranchCoverage += RHS.BranchCoverage;
MCDCCoverage += RHS.MCDCCoverage;
InstantiationCoverage += RHS.InstantiationCoverage; InstantiationCoverage += RHS.InstantiationCoverage;
return *this; return *this;
} }
void addFunction(const FunctionCoverageSummary &Function) { void addFunction(const FunctionCoverageSummary &Function) {
RegionCoverage += Function.RegionCoverage; RegionCoverage += Function.RegionCoverage;
LineCoverage += Function.LineCoverage; LineCoverage += Function.LineCoverage;
BranchCoverage += Function.BranchCoverage; BranchCoverage += Function.BranchCoverage;
MCDCCoverage += Function.MCDCCoverage;
FunctionCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0); FunctionCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0);
} }
void addInstantiation(const FunctionCoverageSummary &Function) { void addInstantiation(const FunctionCoverageSummary &Function) {
InstantiationCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0); InstantiationCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0);
} }
}; };
Show All 16 Lines

llvm/tools/llvm-cov/CoverageSummaryInfo.cpp

Show All 38 Linesstatic void sumBranchExpansions(size_t &NumBranches, size_t &CoveredBranches,
ArrayRef<ExpansionRecord> Expansions) { ArrayRef<ExpansionRecord> Expansions) {
for (const auto &Expansion : Expansions) { for (const auto &Expansion : Expansions) {
auto CE = CM.getCoverageForExpansion(Expansion); auto CE = CM.getCoverageForExpansion(Expansion);
sumBranches(NumBranches, CoveredBranches, CE.getBranches()); sumBranches(NumBranches, CoveredBranches, CE.getBranches());
sumBranchExpansions(NumBranches, CoveredBranches, CM, CE.getExpansions()); sumBranchExpansions(NumBranches, CoveredBranches, CM, CE.getExpansions());
} }
} }
static void sumMCDCPairs(size_t &NumPairs, size_t &CoveredPairs,
const ArrayRef<MCDCRecord> &Records) {
for (const auto &Record : Records)
for (unsigned c = 0; c < Record.getNumConditions(); c++) {
if (!Record.isCondFolded(c))
++NumPairs;
if (Record.isCondIndepPairCovered(c))
++CoveredPairs;
}
}
FunctionCoverageSummary FunctionCoverageSummary
FunctionCoverageSummary::get(const CoverageMapping &CM, FunctionCoverageSummary::get(const CoverageMapping &CM,
const coverage::FunctionRecord &Function) { const coverage::FunctionRecord &Function) {
// Compute the region coverage. // Compute the region coverage.
size_t NumCodeRegions = 0, CoveredRegions = 0; size_t NumCodeRegions = 0, CoveredRegions = 0;
for (auto &CR : Function.CountedRegions) { for (auto &CR : Function.CountedRegions) {
if (CR.Kind != CounterMappingRegion::CodeRegion) if (CR.Kind != CounterMappingRegion::CodeRegion)
continue; continue;
Show All 13 Lines if (LCS.getExecutionCount())
++CoveredLines; ++CoveredLines;
} }
// Compute the branch coverage, including branches from expansions. // Compute the branch coverage, including branches from expansions.
size_t NumBranches = 0, CoveredBranches = 0; size_t NumBranches = 0, CoveredBranches = 0;
sumBranches(NumBranches, CoveredBranches, CD.getBranches()); sumBranches(NumBranches, CoveredBranches, CD.getBranches());
sumBranchExpansions(NumBranches, CoveredBranches, CM, CD.getExpansions()); sumBranchExpansions(NumBranches, CoveredBranches, CM, CD.getExpansions());
size_t NumPairs = 0, CoveredPairs = 0;
sumMCDCPairs(NumPairs, CoveredPairs, CD.getMCDCRecords());
return FunctionCoverageSummary( return FunctionCoverageSummary(
Function.Name, Function.ExecutionCount, Function.Name, Function.ExecutionCount,
RegionCoverageInfo(CoveredRegions, NumCodeRegions), RegionCoverageInfo(CoveredRegions, NumCodeRegions),
LineCoverageInfo(CoveredLines, NumLines), LineCoverageInfo(CoveredLines, NumLines),
BranchCoverageInfo(CoveredBranches, NumBranches)); BranchCoverageInfo(CoveredBranches, NumBranches),
MCDCCoverageInfo(CoveredPairs, NumPairs));
} }
FunctionCoverageSummary FunctionCoverageSummary
FunctionCoverageSummary::get(const InstantiationGroup &Group, FunctionCoverageSummary::get(const InstantiationGroup &Group,
ArrayRef<FunctionCoverageSummary> Summaries) { ArrayRef<FunctionCoverageSummary> Summaries) {
std::string Name; std::string Name;
if (Group.hasName()) { if (Group.hasName()) {
Name = std::string(Group.getName()); Name = std::string(Group.getName());
} else { } else {
llvm::raw_string_ostream OS(Name); llvm::raw_string_ostream OS(Name);
OS << "Definition at line " << Group.getLine() << ", column " OS << "Definition at line " << Group.getLine() << ", column "
<< Group.getColumn(); << Group.getColumn();
} }
FunctionCoverageSummary Summary(Name); FunctionCoverageSummary Summary(Name);
Summary.ExecutionCount = Group.getTotalExecutionCount(); Summary.ExecutionCount = Group.getTotalExecutionCount();
Summary.RegionCoverage = Summaries[0].RegionCoverage; Summary.RegionCoverage = Summaries[0].RegionCoverage;
Summary.LineCoverage = Summaries[0].LineCoverage; Summary.LineCoverage = Summaries[0].LineCoverage;
Summary.BranchCoverage = Summaries[0].BranchCoverage; Summary.BranchCoverage = Summaries[0].BranchCoverage;
Summary.MCDCCoverage = Summaries[0].MCDCCoverage;
for (const auto &FCS : Summaries.drop_front()) { for (const auto &FCS : Summaries.drop_front()) {
Summary.RegionCoverage.merge(FCS.RegionCoverage); Summary.RegionCoverage.merge(FCS.RegionCoverage);
Summary.LineCoverage.merge(FCS.LineCoverage); Summary.LineCoverage.merge(FCS.LineCoverage);
Summary.BranchCoverage.merge(FCS.BranchCoverage); Summary.BranchCoverage.merge(FCS.BranchCoverage);
Summary.MCDCCoverage.merge(FCS.MCDCCoverage);
} }
return Summary; return Summary;
} }

llvm/tools/llvm-cov/CoverageViewOptions.h

Show All 24 Linesstruct CoverageViewOptions {
enum class BranchOutputType { Count, Percent, Off }; enum class BranchOutputType { Count, Percent, Off };
bool Debug; bool Debug;
bool Colors; bool Colors;
bool ShowLineNumbers; bool ShowLineNumbers;
bool ShowLineStats; bool ShowLineStats;
bool ShowRegionMarkers; bool ShowRegionMarkers;
bool ShowMCDC;
bool ShowBranchCounts; bool ShowBranchCounts;
bool ShowBranchPercents; bool ShowBranchPercents;
bool ShowExpandedRegions; bool ShowExpandedRegions;
bool ShowFunctionInstantiations; bool ShowFunctionInstantiations;
bool ShowFullFilenames; bool ShowFullFilenames;
bool ShowBranchSummary; bool ShowBranchSummary;
bool ShowMCDCSummary;
bool ShowRegionSummary; bool ShowRegionSummary;
bool ShowInstantiationSummary; bool ShowInstantiationSummary;
bool ExportSummaryOnly; bool ExportSummaryOnly;
bool SkipExpansions; bool SkipExpansions;
bool SkipFunctions; bool SkipFunctions;
bool SkipBranches; bool SkipBranches;
OutputFormat Format; OutputFormat Format;
BranchOutputType ShowBranches; BranchOutputType ShowBranches;
Show All 38 Lines

llvm/tools/llvm-cov/SourceCoverageView.h

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Linesstruct BranchView {
unsigned getLine() const { return Line; } unsigned getLine() const { return Line; }
friend bool operator<(const BranchView &LHS, const BranchView &RHS) { friend bool operator<(const BranchView &LHS, const BranchView &RHS) {
return LHS.Line < RHS.Line; return LHS.Line < RHS.Line;
} }
}; };
/// A view that represents one or more MCDC regions on a given source line.
struct MCDCView {
std::vector<MCDCRecord> Records;
std::unique_ptr<SourceCoverageView> View;
unsigned Line;
MCDCView(unsigned Line, ArrayRef<MCDCRecord> Records,
std::unique_ptr<SourceCoverageView> View)
: Records(Records), View(std::move(View)), Line(Line) {}
unsigned getLine() const { return Line; }
friend bool operator<(const MCDCView &LHS, const MCDCView &RHS) {
return LHS.Line < RHS.Line;
}
};
/// A file manager that handles format-aware file creation. /// A file manager that handles format-aware file creation.
class CoveragePrinter { class CoveragePrinter {
public: public:
struct StreamDestructor { struct StreamDestructor {
void operator()(raw_ostream *OS) const; void operator()(raw_ostream *OS) const;
}; };
using OwnedStream = std::unique_ptr<raw_ostream, StreamDestructor>; using OwnedStream = std::unique_ptr<raw_ostream, StreamDestructor>;
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Linesclass SourceCoverageView {
CoverageData CoverageInfo; CoverageData CoverageInfo;
/// A container for all expansions (e.g macros) in the source on display. /// A container for all expansions (e.g macros) in the source on display.
std::vector<ExpansionView> ExpansionSubViews; std::vector<ExpansionView> ExpansionSubViews;
/// A container for all branches in the source on display. /// A container for all branches in the source on display.
std::vector<BranchView> BranchSubViews; std::vector<BranchView> BranchSubViews;
/// A container for all MCDC records in the source on display.
std::vector<MCDCView> MCDCSubViews;
/// A container for all instantiations (e.g template functions) in the source /// A container for all instantiations (e.g template functions) in the source
/// on display. /// on display.
std::vector<InstantiationView> InstantiationSubViews; std::vector<InstantiationView> InstantiationSubViews;
/// Get the first uncovered line number for the source file. /// Get the first uncovered line number for the source file.
unsigned getFirstUncoveredLineNo(); unsigned getFirstUncoveredLineNo();
protected: protected:
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linesprotected:
/// Render an instantiation view and any nested views. /// Render an instantiation view and any nested views.
virtual void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV, virtual void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
unsigned ViewDepth) = 0; unsigned ViewDepth) = 0;
/// Render a branch view and any nested views. /// Render a branch view and any nested views.
virtual void renderBranchView(raw_ostream &OS, BranchView &BRV, virtual void renderBranchView(raw_ostream &OS, BranchView &BRV,
unsigned ViewDepth) = 0; unsigned ViewDepth) = 0;
/// Render an MCDC view.
virtual void renderMCDCView(raw_ostream &OS, MCDCView &BRV,
unsigned ViewDepth) = 0;
/// Render \p Title, a project title if one is available, and the /// Render \p Title, a project title if one is available, and the
/// created time. /// created time.
virtual void renderTitle(raw_ostream &OS, StringRef CellText) = 0; virtual void renderTitle(raw_ostream &OS, StringRef CellText) = 0;
/// Render the table header for a given source file. /// Render the table header for a given source file.
virtual void renderTableHeader(raw_ostream &OS, unsigned FirstUncoveredLineNo, virtual void renderTableHeader(raw_ostream &OS, unsigned FirstUncoveredLineNo,
unsigned IndentLevel) = 0; unsigned IndentLevel) = 0;
Show All 34 Linespublic:
/// Add a function instantiation subview to this view. /// Add a function instantiation subview to this view.
void addInstantiation(StringRef FunctionName, unsigned Line, void addInstantiation(StringRef FunctionName, unsigned Line,
std::unique_ptr<SourceCoverageView> View); std::unique_ptr<SourceCoverageView> View);
/// Add a branch subview to this view. /// Add a branch subview to this view.
void addBranch(unsigned Line, ArrayRef<CountedRegion> Regions, void addBranch(unsigned Line, ArrayRef<CountedRegion> Regions,
std::unique_ptr<SourceCoverageView> View); std::unique_ptr<SourceCoverageView> View);
/// Add an MCDC subview to this view.
void addMCDCRecord(unsigned Line, ArrayRef<MCDCRecord> Records,
std::unique_ptr<SourceCoverageView> View);
/// Print the code coverage information for a specific portion of a /// Print the code coverage information for a specific portion of a
/// source file to the output stream. /// source file to the output stream.
void print(raw_ostream &OS, bool WholeFile, bool ShowSourceName, void print(raw_ostream &OS, bool WholeFile, bool ShowSourceName,
bool ShowTitle, unsigned ViewDepth = 0); bool ShowTitle, unsigned ViewDepth = 0);
}; };
} // namespace llvm } // namespace llvm
#endif // LLVM_COV_SOURCECOVERAGEVIEW_H #endif // LLVM_COV_SOURCECOVERAGEVIEW_H

llvm/tools/llvm-cov/SourceCoverageView.cpp

Show First 20 Lines • Show All 168 Lines • ▼ Show 20 Lines
} }
void SourceCoverageView::addBranch(unsigned Line, void SourceCoverageView::addBranch(unsigned Line,
ArrayRef<CountedRegion> Regions, ArrayRef<CountedRegion> Regions,
std::unique_ptr<SourceCoverageView> View) { std::unique_ptr<SourceCoverageView> View) {
BranchSubViews.emplace_back(Line, Regions, std::move(View)); BranchSubViews.emplace_back(Line, Regions, std::move(View));
} }
void SourceCoverageView::addMCDCRecord(
unsigned Line, ArrayRef<MCDCRecord> Records,
std::unique_ptr<SourceCoverageView> View) {
MCDCSubViews.emplace_back(Line, Records, std::move(View));
}
void SourceCoverageView::addInstantiation( void SourceCoverageView::addInstantiation(
StringRef FunctionName, unsigned Line, StringRef FunctionName, unsigned Line,
std::unique_ptr<SourceCoverageView> View) { std::unique_ptr<SourceCoverageView> View) {
InstantiationSubViews.emplace_back(FunctionName, Line, std::move(View)); InstantiationSubViews.emplace_back(FunctionName, Line, std::move(View));
} }
void SourceCoverageView::print(raw_ostream &OS, bool WholeFile, void SourceCoverageView::print(raw_ostream &OS, bool WholeFile,
bool ShowSourceName, bool ShowTitle, bool ShowSourceName, bool ShowTitle,
Show All 9 Linesvoid SourceCoverageView::print(raw_ostream &OS, bool WholeFile,
renderTableHeader(OS, (ViewDepth > 0) ? 0 : getFirstUncoveredLineNo(), renderTableHeader(OS, (ViewDepth > 0) ? 0 : getFirstUncoveredLineNo(),
ViewDepth); ViewDepth);
// We need the expansions, instantiations, and branches sorted so we can go // We need the expansions, instantiations, and branches sorted so we can go
// through them while we iterate lines. // through them while we iterate lines.
llvm::stable_sort(ExpansionSubViews); llvm::stable_sort(ExpansionSubViews);
llvm::stable_sort(InstantiationSubViews); llvm::stable_sort(InstantiationSubViews);
llvm::stable_sort(BranchSubViews); llvm::stable_sort(BranchSubViews);
llvm::stable_sort(MCDCSubViews);
auto NextESV = ExpansionSubViews.begin(); auto NextESV = ExpansionSubViews.begin();
auto EndESV = ExpansionSubViews.end(); auto EndESV = ExpansionSubViews.end();
auto NextISV = InstantiationSubViews.begin(); auto NextISV = InstantiationSubViews.begin();
auto EndISV = InstantiationSubViews.end(); auto EndISV = InstantiationSubViews.end();
auto NextBRV = BranchSubViews.begin(); auto NextBRV = BranchSubViews.begin();
auto EndBRV = BranchSubViews.end(); auto EndBRV = BranchSubViews.end();
auto NextMSV = MCDCSubViews.begin();
auto EndMSV = MCDCSubViews.end();
// Get the coverage information for the file. // Get the coverage information for the file.
auto StartSegment = CoverageInfo.begin(); auto StartSegment = CoverageInfo.begin();
auto EndSegment = CoverageInfo.end(); auto EndSegment = CoverageInfo.end();
LineCoverageIterator LCI{CoverageInfo, 1}; LineCoverageIterator LCI{CoverageInfo, 1};
LineCoverageIterator LCIEnd = LCI.getEnd(); LineCoverageIterator LCIEnd = LCI.getEnd();
unsigned FirstLine = StartSegment != EndSegment ? StartSegment->Line : 0; unsigned FirstLine = StartSegment != EndSegment ? StartSegment->Line : 0;
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines for (; NextISV != EndISV && NextISV->Line == LI.line_number(); ++NextISV) {
renderInstantiationView(OS, *NextISV, ViewDepth + 1); renderInstantiationView(OS, *NextISV, ViewDepth + 1);
RenderedSubView = true; RenderedSubView = true;
} }
for (; NextBRV != EndBRV && NextBRV->Line == LI.line_number(); ++NextBRV) { for (; NextBRV != EndBRV && NextBRV->Line == LI.line_number(); ++NextBRV) {
renderViewDivider(OS, ViewDepth + 1); renderViewDivider(OS, ViewDepth + 1);
renderBranchView(OS, *NextBRV, ViewDepth + 1); renderBranchView(OS, *NextBRV, ViewDepth + 1);
RenderedSubView = true; RenderedSubView = true;
} }
for (; NextMSV != EndMSV && NextMSV->Line == LI.line_number(); ++NextMSV) {
renderViewDivider(OS, ViewDepth + 1);
renderMCDCView(OS, *NextMSV, ViewDepth + 1);
RenderedSubView = true;
}
if (RenderedSubView) if (RenderedSubView)
renderViewDivider(OS, ViewDepth + 1); renderViewDivider(OS, ViewDepth + 1);
renderLineSuffix(OS, ViewDepth); renderLineSuffix(OS, ViewDepth);
} }
renderViewFooter(OS); renderViewFooter(OS);
} }

llvm/tools/llvm-cov/SourceCoverageViewHTML.h

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines void renderExpansionSite(raw_ostream &OS, LineRef L,
unsigned ViewDepth) override; unsigned ViewDepth) override;
void renderExpansionView(raw_ostream &OS, ExpansionView &ESV, void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
unsigned ViewDepth) override; unsigned ViewDepth) override;
void renderBranchView(raw_ostream &OS, BranchView &BRV, void renderBranchView(raw_ostream &OS, BranchView &BRV,
unsigned ViewDepth) override; unsigned ViewDepth) override;
void renderMCDCView(raw_ostream &OS, MCDCView &BRV,
unsigned ViewDepth) override;
void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV, void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
unsigned ViewDepth) override; unsigned ViewDepth) override;
void renderLineCoverageColumn(raw_ostream &OS, void renderLineCoverageColumn(raw_ostream &OS,
const LineCoverageStats &Line) override; const LineCoverageStats &Line) override;
void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) override; void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) override;
Show All 19 Lines

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

Show First 20 Lines • Show All 309 Lines • ▼ Show 20 Linesstatic void emitColumnLabelsForIndex(raw_ostream &OS,
if (Opts.ShowInstantiationSummary) if (Opts.ShowInstantiationSummary)
Columns.emplace_back( Columns.emplace_back(
tag("td", "Instantiation Coverage", "column-entry-bold")); tag("td", "Instantiation Coverage", "column-entry-bold"));
Columns.emplace_back(tag("td", "Line Coverage", "column-entry-bold")); Columns.emplace_back(tag("td", "Line Coverage", "column-entry-bold"));
if (Opts.ShowRegionSummary) if (Opts.ShowRegionSummary)
Columns.emplace_back(tag("td", "Region Coverage", "column-entry-bold")); Columns.emplace_back(tag("td", "Region Coverage", "column-entry-bold"));
if (Opts.ShowBranchSummary) if (Opts.ShowBranchSummary)
Columns.emplace_back(tag("td", "Branch Coverage", "column-entry-bold")); Columns.emplace_back(tag("td", "Branch Coverage", "column-entry-bold"));
if (Opts.ShowMCDCSummary)
Columns.emplace_back(tag("td", "MC/DC", "column-entry-bold"));
OS << tag("tr", join(Columns.begin(), Columns.end(), "")); OS << tag("tr", join(Columns.begin(), Columns.end(), ""));
} }
std::string std::string
CoveragePrinterHTML::buildLinkToFile(StringRef SF, CoveragePrinterHTML::buildLinkToFile(StringRef SF,
const FileCoverageSummary &FCS) const { const FileCoverageSummary &FCS) const {
SmallString<128> LinkTextStr(sys::path::relative_path(FCS.Name)); SmallString<128> LinkTextStr(sys::path::relative_path(FCS.Name));
sys::path::remove_dots(LinkTextStr, /*remove_dot_dot=*/true); sys::path::remove_dots(LinkTextStr, /*remove_dot_dot=*/true);
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Linesvoid CoveragePrinterHTML::emitFileSummary(raw_ostream &OS, StringRef SF,
if (Opts.ShowRegionSummary) if (Opts.ShowRegionSummary)
AddCoverageTripleToColumn(FCS.RegionCoverage.getCovered(), AddCoverageTripleToColumn(FCS.RegionCoverage.getCovered(),
FCS.RegionCoverage.getNumRegions(), FCS.RegionCoverage.getNumRegions(),
FCS.RegionCoverage.getPercentCovered()); FCS.RegionCoverage.getPercentCovered());
if (Opts.ShowBranchSummary) if (Opts.ShowBranchSummary)
AddCoverageTripleToColumn(FCS.BranchCoverage.getCovered(), AddCoverageTripleToColumn(FCS.BranchCoverage.getCovered(),
FCS.BranchCoverage.getNumBranches(), FCS.BranchCoverage.getNumBranches(),
FCS.BranchCoverage.getPercentCovered()); FCS.BranchCoverage.getPercentCovered());
if (Opts.ShowMCDCSummary)
AddCoverageTripleToColumn(FCS.MCDCCoverage.getCoveredPairs(),
FCS.MCDCCoverage.getNumPairs(),
FCS.MCDCCoverage.getPercentCovered());
if (IsTotals) if (IsTotals)
OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row-bold"); OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row-bold");
else else
OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row"); OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row");
} }
Error CoveragePrinterHTML::createIndexFile( Error CoveragePrinterHTML::createIndexFile(
▲ Show 20 Lines • Show All 322 Lines • ▼ Show 20 Lines else
OS << format("%0.2f", FalsePercent) << "%"; OS << format("%0.2f", FalsePercent) << "%";
OS << "]\n"; OS << "]\n";
} }
OS << EndPre; OS << EndPre;
OS << EndExpansionDiv; OS << EndExpansionDiv;
} }
void SourceCoverageViewHTML::renderMCDCView(raw_ostream &OS, MCDCView &MRV,
unsigned ViewDepth) {
for (auto &Record : MRV.Records) {
OS << BeginExpansionDiv;
OS << BeginPre;
OS << " MC/DC Decision Region (";
// Display Line + Column information.
const CounterMappingRegion &DecisionRegion = Record.getDecisionRegion();
std::string LineNoStr = utostr(uint64_t(DecisionRegion.LineStart));
std::string ColNoStr = utostr(uint64_t(DecisionRegion.ColumnStart));
std::string TargetName = "L" + LineNoStr;
OS << tag("span",
a("#" + TargetName, tag("span", LineNoStr + ":" + ColNoStr),
TargetName),
"line-number") +
") to (";
LineNoStr = utostr(uint64_t(DecisionRegion.LineEnd));
ColNoStr = utostr(uint64_t(DecisionRegion.ColumnEnd));
OS << tag("span",
a("#" + TargetName, tag("span", LineNoStr + ":" + ColNoStr),
TargetName),
"line-number") +
")\n\n";
// Display MC/DC Information.
OS << " Number of Conditions: " << Record.getNumConditions() << "\n";
for (unsigned i = 0; i < Record.getNumConditions(); i++) {
OS << " " << Record.getConditionHdrStr(i);
}
OS << "\n";
OS << " Executed MC/DC Test Vectors:\n\n ";
OS << Record.getTestVectorHdrStr();
for (unsigned i = 0; i < Record.getNumTestVectors(); i++)
OS << Record.getTestVectorStr(i);
OS << "\n";
for (unsigned i = 0; i < Record.getNumConditions(); i++)
OS << Record.getCondCoverageStr(i);
OS << " MC/DC Coverage for Expression: ";
OS << format("%0.2f", Record.getPercentCovered()) << "%\n";
OS << EndPre;
OS << EndExpansionDiv;
}
return;
}
void SourceCoverageViewHTML::renderInstantiationView(raw_ostream &OS, void SourceCoverageViewHTML::renderInstantiationView(raw_ostream &OS,
InstantiationView &ISV, InstantiationView &ISV,
unsigned ViewDepth) { unsigned ViewDepth) {
OS << BeginExpansionDiv; OS << BeginExpansionDiv;
if (!ISV.View) if (!ISV.View)
OS << BeginSourceNameDiv OS << BeginSourceNameDiv
<< tag("pre", << tag("pre",
escape("Unexecuted instantiation: " + ISV.FunctionName.str(), escape("Unexecuted instantiation: " + ISV.FunctionName.str(),
Show All 36 Lines

llvm/tools/llvm-cov/SourceCoverageViewText.h

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines void renderExpansionSite(raw_ostream &OS, LineRef L,
unsigned ViewDepth) override; unsigned ViewDepth) override;
void renderExpansionView(raw_ostream &OS, ExpansionView &ESV, void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
unsigned ViewDepth) override; unsigned ViewDepth) override;
void renderBranchView(raw_ostream &OS, BranchView &BRV, void renderBranchView(raw_ostream &OS, BranchView &BRV,
unsigned ViewDepth) override; unsigned ViewDepth) override;
void renderMCDCView(raw_ostream &OS, MCDCView &BRV,
unsigned ViewDepth) override;
void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV, void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
unsigned ViewDepth) override; unsigned ViewDepth) override;
void renderLineCoverageColumn(raw_ostream &OS, void renderLineCoverageColumn(raw_ostream &OS,
const LineCoverageStats &Line) override; const LineCoverageStats &Line) override;
void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) override; void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) override;
Show All 19 Lines

llvm/tools/llvm-cov/SourceCoverageViewText.cpp

Show First 20 Lines • Show All 264 Lines • ▼ Show 20 Lines for (const auto &R : BRV.Regions) {
if (getOptions().ShowBranchCounts) if (getOptions().ShowBranchCounts)
OS << ": " << formatCount(R.FalseExecutionCount); OS << ": " << formatCount(R.FalseExecutionCount);
else else
OS << ": " << format("%0.2f", FalsePercent) << "%"; OS << ": " << format("%0.2f", FalsePercent) << "%";
OS << "]\n"; OS << "]\n";
} }
} }
void SourceCoverageViewText::renderMCDCView(raw_ostream &OS, MCDCView &MRV,
unsigned ViewDepth) {
for (auto &Record : MRV.Records) {
renderLinePrefix(OS, ViewDepth);
OS << "---> MC/DC Decision Region (";
// Display Line + Column information.
const CounterMappingRegion &DecisionRegion = Record.getDecisionRegion();
OS << DecisionRegion.LineStart << ":";
OS << DecisionRegion.ColumnStart << ") to (";
OS << DecisionRegion.LineEnd << ":";
OS << DecisionRegion.ColumnEnd << ")\n";
renderLinePrefix(OS, ViewDepth);
OS << "\n";
// Display MC/DC Information.
renderLinePrefix(OS, ViewDepth);
OS << " Number of Conditions: " << Record.getNumConditions() << "\n";
for (unsigned i = 0; i < Record.getNumConditions(); i++) {
renderLinePrefix(OS, ViewDepth);
OS << " " << Record.getConditionHdrStr(i);
}
renderLinePrefix(OS, ViewDepth);
OS << "\n";
renderLinePrefix(OS, ViewDepth);
OS << " Executed MC/DC Test Vectors:\n";
renderLinePrefix(OS, ViewDepth);
OS << "\n";
renderLinePrefix(OS, ViewDepth);
OS << " ";
OS << Record.getTestVectorHdrStr();
for (unsigned i = 0; i < Record.getNumTestVectors(); i++) {
renderLinePrefix(OS, ViewDepth);
OS << Record.getTestVectorStr(i);
}
renderLinePrefix(OS, ViewDepth);
OS << "\n";
for (unsigned i = 0; i < Record.getNumConditions(); i++) {
renderLinePrefix(OS, ViewDepth);
OS << Record.getCondCoverageStr(i);
}
renderLinePrefix(OS, ViewDepth);
OS << " MC/DC Coverage for Decision: ";
colored_ostream(OS, raw_ostream::RED,
getOptions().Colors && Record.getPercentCovered() < 100.0,
/*Bold=*/false, /*BG=*/true)
<< format("%0.2f", Record.getPercentCovered()) << "%\n";
renderLinePrefix(OS, ViewDepth);
OS << "\n";
}
}
void SourceCoverageViewText::renderInstantiationView(raw_ostream &OS, void SourceCoverageViewText::renderInstantiationView(raw_ostream &OS,
InstantiationView &ISV, InstantiationView &ISV,
unsigned ViewDepth) { unsigned ViewDepth) {
renderLinePrefix(OS, ViewDepth); renderLinePrefix(OS, ViewDepth);
OS << ' '; OS << ' ';
if (!ISV.View) if (!ISV.View)
getOptions().colored_ostream(OS, raw_ostream::RED) getOptions().colored_ostream(OS, raw_ostream::RED)
<< "Unexecuted instantiation: " << ISV.FunctionName << "\n"; << "Unexecuted instantiation: " << ISV.FunctionName << "\n";
Show All 19 Lines

llvm/unittests/ProfileData/CoverageMappingTest.cpp

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Lines void addCMR(Counter C, StringRef File, unsigned LS, unsigned CS, unsigned LE,
unsigned CE, bool Skipped = false) { unsigned CE, bool Skipped = false) {
auto &Regions = InputFunctions.back().Regions; auto &Regions = InputFunctions.back().Regions;
unsigned FileID = getFileIndexForFunction(File); unsigned FileID = getFileIndexForFunction(File);
Regions.push_back( Regions.push_back(
Skipped ? CounterMappingRegion::makeSkipped(FileID, LS, CS, LE, CE) Skipped ? CounterMappingRegion::makeSkipped(FileID, LS, CS, LE, CE)
: CounterMappingRegion::makeRegion(C, FileID, LS, CS, LE, CE)); : CounterMappingRegion::makeRegion(C, FileID, LS, CS, LE, CE));
} }
void addMCDCDecisionCMR(unsigned Mask, unsigned NC, StringRef File,
unsigned LS, unsigned CS, unsigned LE, unsigned CE) {
auto &Regions = InputFunctions.back().Regions;
unsigned FileID = getFileIndexForFunction(File);
Regions.push_back(CounterMappingRegion::makeDecisionRegion(Mask, NC,
FileID, LS, CS, LE, CE));
}
void addMCDCBranchCMR(Counter C1, Counter C2, unsigned ID, unsigned TrueID,
unsigned FalseID, StringRef File, unsigned LS,
unsigned CS, unsigned LE, unsigned CE) {
auto &Regions = InputFunctions.back().Regions;
unsigned FileID = getFileIndexForFunction(File);
Regions.push_back(CounterMappingRegion::makeBranchRegion(C1, C2, ID,
TrueID, FalseID, FileID, LS, CS, LE, CE));
}
void addExpansionCMR(StringRef File, StringRef ExpandedFile, unsigned LS, void addExpansionCMR(StringRef File, StringRef ExpandedFile, unsigned LS,
unsigned CS, unsigned LE, unsigned CE) { unsigned CS, unsigned LE, unsigned CE) {
InputFunctions.back().Regions.push_back(CounterMappingRegion::makeExpansion( InputFunctions.back().Regions.push_back(CounterMappingRegion::makeExpansion(
getFileIndexForFunction(File), getFileIndexForFunction(ExpandedFile), getFileIndexForFunction(File), getFileIndexForFunction(ExpandedFile),
LS, CS, LE, CE)); LS, CS, LE, CE));
} }
void addExpression(CounterExpression CE) { void addExpression(CounterExpression CE) {
▲ Show 20 Lines • Show All 624 Lines • ▼ Show 20 LinesTEST_P(CoverageMappingTest, non_code_region_counters) {
std::vector<std::string> Names; std::vector<std::string> Names;
for (const auto &Func : LoadedCoverage->getCoveredFunctions()) { for (const auto &Func : LoadedCoverage->getCoveredFunctions()) {
Names.push_back(Func.Name); Names.push_back(Func.Name);
ASSERT_EQ(2U, Func.CountedRegions.size()); ASSERT_EQ(2U, Func.CountedRegions.size());
} }
ASSERT_EQ(1U, Names.size()); ASSERT_EQ(1U, Names.size());
} }
// Test that MCDC bitmasks not associated with any code regions are allowed.
TEST_P(CoverageMappingTest, non_code_region_bitmask) {
// No records in profdata
startFunction("func", 0x1234);
addCMR(Counter::getCounter(0), "file", 1, 1, 5, 5);
addCMR(Counter::getCounter(1), "file", 1, 1, 5, 5);
addCMR(Counter::getCounter(2), "file", 1, 1, 5, 5);
addCMR(Counter::getCounter(3), "file", 1, 1, 5, 5);
addMCDCDecisionCMR(0, 2, "file", 7, 1, 7, 6);
addMCDCBranchCMR(Counter::getCounter(0), Counter::getCounter(1), 1, 2, 0,
"file", 7, 2, 7, 3);
addMCDCBranchCMR(Counter::getCounter(2), Counter::getCounter(3), 2, 0, 0,
"file", 7, 4, 7, 5);
EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
std::vector<std::string> Names;
for (const auto &Func : LoadedCoverage->getCoveredFunctions()) {
Names.push_back(Func.Name);
ASSERT_EQ(2U, Func.CountedBranchRegions.size());
ASSERT_EQ(1U, Func.MCDCRecords.size());
}
ASSERT_EQ(1U, Names.size());
}
TEST_P(CoverageMappingTest, strip_filename_prefix) { TEST_P(CoverageMappingTest, strip_filename_prefix) {
ProfileWriter.addRecord({"file1:func", 0x1234, {0}}, Err); ProfileWriter.addRecord({"file1:func", 0x1234, {0}}, Err);
startFunction("file1:func", 0x1234); startFunction("file1:func", 0x1234);
addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9); addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded()); EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
std::vector<std::string> Names; std::vector<std::string> Names;
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines