1 //=-- CoverageMapping.cpp - Code coverage mapping support ---------*- C++ -*-=//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for clang's and llvm's instrumentation based
13 //===----------------------------------------------------------------------===//
15 #include "llvm/ProfileData/CoverageMapping.h"
16 #include "llvm/Support/ErrorHandling.h"
19 using namespace coverage;
21 CounterExpressionBuilder::CounterExpressionBuilder(unsigned NumCounterValues) {
22 Terms.resize(NumCounterValues);
25 Counter CounterExpressionBuilder::get(const CounterExpression &E) {
26 for (unsigned I = 0, S = Expressions.size(); I < S; ++I) {
27 if (Expressions[I] == E)
28 return Counter::getExpression(I);
30 Expressions.push_back(E);
31 return Counter::getExpression(Expressions.size() - 1);
34 void CounterExpressionBuilder::extractTerms(Counter C, int Sign) {
35 switch (C.getKind()) {
38 case Counter::CounterValueReference:
39 Terms[C.getCounterID()] += Sign;
41 case Counter::Expression:
42 const auto &E = Expressions[C.getExpressionID()];
43 extractTerms(E.LHS, Sign);
44 extractTerms(E.RHS, E.Kind == CounterExpression::Subtract ? -Sign : Sign);
49 Counter CounterExpressionBuilder::simplify(Counter ExpressionTree) {
50 // Gather constant terms.
53 extractTerms(ExpressionTree);
57 // Note: the additions are created first
58 // to avoid creation of a tree like ((0 - X) + Y) instead of (Y - X).
59 for (unsigned I = 0, S = Terms.size(); I < S; ++I) {
62 for (int J = 0; J < Terms[I]; ++J) {
64 C = Counter::getCounter(I);
66 C = get(CounterExpression(CounterExpression::Add, C,
67 Counter::getCounter(I)));
71 // Create subtractions.
72 for (unsigned I = 0, S = Terms.size(); I < S; ++I) {
75 for (int J = 0; J < (-Terms[I]); ++J)
76 C = get(CounterExpression(CounterExpression::Subtract, C,
77 Counter::getCounter(I)));
82 Counter CounterExpressionBuilder::add(Counter LHS, Counter RHS) {
83 return simplify(get(CounterExpression(CounterExpression::Add, LHS, RHS)));
86 Counter CounterExpressionBuilder::subtract(Counter LHS, Counter RHS) {
88 get(CounterExpression(CounterExpression::Subtract, LHS, RHS)));
91 void CounterMappingContext::dump(const Counter &C,
92 llvm::raw_ostream &OS) const {
93 switch (C.getKind()) {
97 case Counter::CounterValueReference:
98 OS << '#' << C.getCounterID();
100 case Counter::Expression: {
101 if (C.getExpressionID() >= Expressions.size())
103 const auto &E = Expressions[C.getExpressionID()];
106 OS << (E.Kind == CounterExpression::Subtract ? " - " : " + ");
112 if (CounterValues.empty())
114 ErrorOr<int64_t> Value = evaluate(C);
117 OS << '[' << *Value << ']';
120 ErrorOr<int64_t> CounterMappingContext::evaluate(const Counter &C) const {
121 switch (C.getKind()) {
124 case Counter::CounterValueReference:
125 if (C.getCounterID() >= CounterValues.size())
126 return std::make_error_code(std::errc::argument_out_of_domain);
127 return CounterValues[C.getCounterID()];
128 case Counter::Expression: {
129 if (C.getExpressionID() >= Expressions.size())
130 return std::make_error_code(std::errc::argument_out_of_domain);
131 const auto &E = Expressions[C.getExpressionID()];
132 ErrorOr<int64_t> LHS = evaluate(E.LHS);
135 ErrorOr<int64_t> RHS = evaluate(E.RHS);
138 return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS;
141 llvm_unreachable("Unhandled CounterKind");