26463753889

Committed 26 May 2026 05:18PM UTC coverage: 60.864% (-0.02%) from 60.886%

Build # 26463753889

Build Type

Pull #719

github

Committed by

web-flow

Commit Message

Merge 0b90ddd88 into 707dadcf8

Pull Request Pull Request #719: Libnode ptr edges

Coverage Stats

961 of 1749 new or added lines in 52 files covered. (54.95%)

90 existing lines in 29 files now uncovered.

35222 of 57870 relevant lines covered (60.86%)

11043.61 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.17

/sdfg/src/data_flow/pointer_metadata.cpp

#include "sdfg/data_flow/pointer_metadata.h"

#include "cereal/types/utility.hpp"
#include "sdfg/serializer/json_serializer.h"

namespace sdfg::data_flow {

MemoryAccessPatternType MemoryAccessPattern::ref() const {
    return std::unique_ptr<
        MemoryAccessPattern,
        AccessPatternsDeleter>(const_cast<MemoryAccessPattern*>(this), AccessPatternsDeleter(false));
}

MemoryAccessPatternType ConvexAccessPattern::clone() const {
    return std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter>(new ConvexAccessPattern(size_));
}

void ConvexAccessPattern::serialize_to_json(nlohmann::json& entry) {
    entry["type"] = "ConvexAccessPattern";
    serializer::JSONSerializer serializer;
    entry["size"] = serializer.expression(size_);
    entry["not_sparse"] = not_sparse_;
}

MemoryAccessPatternType ConvexAccessPattern::create(symbolic::Expression size, bool not_sparse) {
    return std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter>(new ConvexAccessPattern(size, not_sparse));
}

MemoryAccessPatternType NoAccessPattern::instance() {
    static std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter> instance(new NoAccessPattern());
    return instance->ref();
}

void NoAccessPattern::serialize_to_json(nlohmann::json& entry) { entry["type"] = "NoAccessPattern"; }

MemoryAccessPatternType NoAccessPattern::clone() const { return this->ref(); }

PointerAccessType PointerAccessMeta::ref() const {
    return std::unique_ptr<
        PointerAccessMeta,
        PtrAccessDeleter>(const_cast<PointerAccessMeta*>(this), PtrAccessDeleter(false));
}

PointerAccessType PointerAccessMeta::create_read_only(const symbolic::Expression& size, bool no_capture) {
    return std::unique_ptr<PointerAccessMeta, PtrAccessDeleter>(new PointerReadOnly(size, no_capture));
}

PointerAccessType PointerAccessMeta::create_invalidate() {
    return std::unique_ptr<PointerAccessMeta, PtrAccessDeleter>(new PointerInvalidate());
}

PointerAccessType PointerAccessMeta::create_full_write_only(const symbolic::Expression& size, bool no_capture) {
    return std::unique_ptr<
        PointerAccessMeta,
        PtrAccessDeleter>(new PointerFullWriteOnly(size, no_capture), PtrAccessDeleter(true));
}

PointerAccessType PointerAccessMeta::
    create_generic(MemoryAccessPatternType read_pattern, MemoryAccessPatternType write_pattern, bool no_capture) {
    return std::unique_ptr<
        PointerAccessMeta,
        PtrAccessDeleter>(new PointerGenericAccess(std::move(read_pattern), std::move(write_pattern), no_capture));
}

PointerReadOnly::PointerReadOnly(symbolic::Expression size, bool no_capture) : size_(size), no_capture_(no_capture) {}

MemoryAccessPatternType PointerReadOnly::access_read_pattern() const {
    if (size_.is_null()) {
        return {};
    } else {
        return ConvexAccessPattern::create(size_);
    }
}

MemoryAccessPatternType PointerReadOnly::access_write_pattern() const { return NoAccessPattern::instance(); }

void PointerReadOnly::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {
    size_ = symbolic::subs(size_, old_expression, new_expression);
}

PointerAccessType PointerReadOnly::clone() const { return PointerAccessType(new PointerReadOnly(size_, no_capture_)); }

void PointerReadOnly::serialize_to_json(nlohmann::json& entry) {
    serializer::JSONSerializer serializer;
    entry["type"] = "PointerReadOnly";
    entry["size"] = serializer.expression(size_);
    entry["no_capture"] = no_capture_;
}

PointerFullWriteOnly::PointerFullWriteOnly(symbolic::Expression size, bool no_capture)
    : size_(size), no_capture_(no_capture) {}

MemoryAccessPatternType PointerFullWriteOnly::access_write_pattern() const {
    if (size_.is_null()) {
        return nullptr;
    } else {
        return ConvexAccessPattern::create(size_, true);
    }
}

MemoryAccessPatternType PointerFullWriteOnly::access_read_pattern() const { return NoAccessPattern::instance(); }

void PointerFullWriteOnly::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {
    size_ = symbolic::subs(size_, old_expression, new_expression);
}

PointerAccessType PointerFullWriteOnly::clone() const {
    return PointerAccessType(new PointerFullWriteOnly(size_, no_capture_));
}

void PointerFullWriteOnly::serialize_to_json(nlohmann::json& entry) {
    serializer::JSONSerializer serializer;
    entry["type"] = "PointerWriteOnly";
    entry["size"] = serializer.expression(size_);
    entry["no_capture"] = no_capture_;
}

PointerGenericAccess::
    PointerGenericAccess(MemoryAccessPatternType read_pattern, MemoryAccessPatternType write_pattern, bool no_capture)
    : read_pattern_(std::move(read_pattern)), write_pattern_(std::move(write_pattern)), no_capture_(no_capture) {}

MemoryAccessPatternType PointerGenericAccess::access_read_pattern() const {
    return read_pattern_ ? read_pattern_->ref() : nullptr;
}

MemoryAccessPatternType PointerGenericAccess::access_write_pattern() const {
    return write_pattern_ ? write_pattern_->ref() : nullptr;
}

bool PointerGenericAccess::may_contain_reads() const { return !read_pattern_ || !read_pattern_->empty(); }

bool PointerGenericAccess::may_contain_writes() const { return !write_pattern_ || !write_pattern_->empty(); }

void PointerGenericAccess::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {
    if (read_pattern_) {
        read_pattern_->replace(old_expression, new_expression);
    }
    if (write_pattern_) {
        write_pattern_->replace(old_expression, new_expression);
    }
}

PointerAccessType PointerGenericAccess::clone() const {
    auto rd_patt_new = read_pattern_ ? read_pattern_->clone() : nullptr;
    auto wr_patt_new = write_pattern_ ? write_pattern_->clone() : nullptr;
    return PointerAccessType(new PointerGenericAccess(std::move(rd_patt_new), std::move(wr_patt_new), no_capture_));
}

void PointerGenericAccess::serialize_to_json(nlohmann::json& entry) {
    entry["type"] = "PointerGenericAccess";
    if (read_pattern_) {
        read_pattern_->serialize_to_json(entry["read_pattern"]);
    }
    if (write_pattern_) {
        write_pattern_->serialize_to_json(entry["write_pattern"]);
    }
    entry["no_capture"] = no_capture_;
}

PointerAccessType PointerInvalidate::clone() const { return PointerAccessType(new PointerInvalidate()); }

void PointerInvalidate::serialize_to_json(nlohmann::json& entry) { entry["type"] = "PointerInvalidate"; }

PointerAccessType PointerAccessMetaSerializer::deserialize(const nlohmann::json& entry) {
    if (entry.is_null()) {
        return nullptr;
    } else {
        auto type = entry.at("type").get<std::string>();

        if (type == "PointerInvalidate") {
            return PointerAccessMeta::create_invalidate();
        } else if (type == "PointerReadOnly") {
            return deserialize_read_only(entry);
        } else if (type == "PointerWriteOnly") {
            return deserialize_write_only(entry);
        } else if (type == "PointerGenericAccess") {
            return deserialize_generic(entry);
        } else {
            throw std::runtime_error("Unknown MemoryAccessPattern type: " + type);
        }
    }
}

std::vector<PointerAccessType> PointerAccessMetaSerializer::deserialize_list(nlohmann::json::const_reference list) {
    std::vector<PointerAccessType> result;
    for (const auto& entry : list) {
        result.push_back(deserialize(entry));
    }
    return result;
}

std::vector<PointerAccessType> PointerAccessMetaSerializer::
    deserialize_list(nlohmann::json::const_iterator key, const nlohmann::json& parent) {
    if (key != parent.end()) {
        return deserialize_list(*key);
    } else {
        return {};
    }
}

PointerAccessType PointerAccessMetaSerializer::deserialize_read_only(nlohmann::json::const_reference entry) {
    serializer::JSONSerializer serializer;
    bool no_capture = entry.at("no_capture").get<bool>();
    auto size = serializer.json_to_expr(entry.at("size"));
    return PointerAccessMeta::create_read_only(size, no_capture);
}

PointerAccessType PointerAccessMetaSerializer::deserialize_write_only(nlohmann::json::const_reference entry) {
    serializer::JSONSerializer serializer;
    bool no_capture = entry.at("no_capture").get<bool>();
    auto size = serializer.json_to_expr(entry.at("size"));
    return PointerAccessMeta::create_full_write_only(size, no_capture);
}

PointerAccessType PointerAccessMetaSerializer::deserialize_generic(nlohmann::json::const_reference entry) {
    auto read_pattern = deserialize_access_pattern(entry.at("read_pattern"));
    auto write_pattern = deserialize_access_pattern(entry.at("write_pattern"));
    bool no_capture = entry.at("no_capture").get<bool>();
    return PointerAccessMeta::create_generic(std::move(read_pattern), std::move(write_pattern), no_capture);
}

MemoryAccessPatternType PointerAccessMetaSerializer::deserialize_convex_pattern(nlohmann::json::const_reference entry) {
    serializer::JSONSerializer serializer;
    auto size = serializer.json_to_expr(entry.at("size"));
    bool not_sparse = entry.at("not_sparse").get<bool>();
    return ConvexAccessPattern::create(size, not_sparse);
}

MemoryAccessPatternType PointerAccessMetaSerializer::deserialize_access_pattern(nlohmann::json::const_reference entry) {
    if (entry.is_null()) {
        return nullptr;
    } else {
        auto type = entry.at("type").get<std::string>();
        if (type == "NoAccessPattern") {
            return NoAccessPattern::instance();
        } else if (type == "ConvexAccessPattern") {
            return deserialize_convex_pattern(entry);
        } else {
            throw std::runtime_error("Unknown MemoryAccessPattern type: " + type);
        }
    }
}

nlohmann::json PointerAccessMetaSerializer::serialize(const std::vector<PointerAccessType>& vector) {
    auto arr = nlohmann::json::array();
    for (const auto& entry : vector) {
        nlohmann::json j;
        entry->serialize_to_json(j);
        arr.push_back(j);
    }
    return arr;
}

} // namespace sdfg::data_flow

1	#include "sdfg/data_flow/pointer_metadata.h"
2
3	#include "cereal/types/utility.hpp"
4	#include "sdfg/serializer/json_serializer.h"
5
6	namespace sdfg::data_flow {
7
8	MemoryAccessPatternType MemoryAccessPattern::ref() const {	8✔
9	return std::unique_ptr<	8✔
10	MemoryAccessPattern,	8✔
11	AccessPatternsDeleter>(const_cast<MemoryAccessPattern*>(this), AccessPatternsDeleter(false));	8✔
12	}	8✔
13
NEW 14	MemoryAccessPatternType ConvexAccessPattern::clone() const {	×
NEW 15	return std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter>(new ConvexAccessPattern(size_));	×
NEW 16	}	×
17
18	void ConvexAccessPattern::serialize_to_json(nlohmann::json& entry) {	1✔
19	entry["type"] = "ConvexAccessPattern";	1✔
20	serializer::JSONSerializer serializer;	1✔
21	entry["size"] = serializer.expression(size_);	1✔
22	entry["not_sparse"] = not_sparse_;	1✔
23	}	1✔
24
25	MemoryAccessPatternType ConvexAccessPattern::create(symbolic::Expression size, bool not_sparse) {	8✔
26	return std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter>(new ConvexAccessPattern(size, not_sparse));	8✔
27	}	8✔
28
29	MemoryAccessPatternType NoAccessPattern::instance() {	6✔
30	static std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter> instance(new NoAccessPattern());	6✔
31	return instance->ref();	6✔
32	}	6✔
33
34	void NoAccessPattern::serialize_to_json(nlohmann::json& entry) { entry["type"] = "NoAccessPattern"; }	1✔
35
NEW 36	MemoryAccessPatternType NoAccessPattern::clone() const { return this->ref(); }	×
37
NEW 38	PointerAccessType PointerAccessMeta::ref() const {	×
NEW 39	return std::unique_ptr<	×
NEW 40	PointerAccessMeta,	×
NEW 41	PtrAccessDeleter>(const_cast<PointerAccessMeta*>(this), PtrAccessDeleter(false));	×
NEW 42	}	×
43
44	PointerAccessType PointerAccessMeta::create_read_only(const symbolic::Expression& size, bool no_capture) {	6✔
45	return std::unique_ptr<PointerAccessMeta, PtrAccessDeleter>(new PointerReadOnly(size, no_capture));	6✔
46	}	6✔
47
48	PointerAccessType PointerAccessMeta::create_invalidate() {	5✔
49	return std::unique_ptr<PointerAccessMeta, PtrAccessDeleter>(new PointerInvalidate());	5✔
50	}	5✔
51
52	PointerAccessType PointerAccessMeta::create_full_write_only(const symbolic::Expression& size, bool no_capture) {	5✔
53	return std::unique_ptr<	5✔
54	PointerAccessMeta,	5✔
55	PtrAccessDeleter>(new PointerFullWriteOnly(size, no_capture), PtrAccessDeleter(true));	5✔
56	}	5✔
57
58	PointerAccessType PointerAccessMeta::
59	create_generic(MemoryAccessPatternType read_pattern, MemoryAccessPatternType write_pattern, bool no_capture) {	3✔
60	return std::unique_ptr<	3✔
61	PointerAccessMeta,	3✔
62	PtrAccessDeleter>(new PointerGenericAccess(std::move(read_pattern), std::move(write_pattern), no_capture));	3✔
63	}	3✔
64
65	PointerReadOnly::PointerReadOnly(symbolic::Expression size, bool no_capture) : size_(size), no_capture_(no_capture) {}	6✔
66
67	MemoryAccessPatternType PointerReadOnly::access_read_pattern() const {	2✔
68	if (size_.is_null()) {	2✔
NEW 69	return {};	×
70	} else {	2✔
71	return ConvexAccessPattern::create(size_);	2✔
72	}	2✔
73	}	2✔
74
75	MemoryAccessPatternType PointerReadOnly::access_write_pattern() const { return NoAccessPattern::instance(); }	2✔
76
NEW 77	void PointerReadOnly::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
NEW 78	size_ = symbolic::subs(size_, old_expression, new_expression);	×
NEW 79	}	×
80
NEW 81	PointerAccessType PointerReadOnly::clone() const { return PointerAccessType(new PointerReadOnly(size_, no_capture_)); }	×
82
83	void PointerReadOnly::serialize_to_json(nlohmann::json& entry) {	1✔
84	serializer::JSONSerializer serializer;	1✔
85	entry["type"] = "PointerReadOnly";	1✔
86	entry["size"] = serializer.expression(size_);	1✔
87	entry["no_capture"] = no_capture_;	1✔
88	}	1✔
89
90	PointerFullWriteOnly::PointerFullWriteOnly(symbolic::Expression size, bool no_capture)
91	: size_(size), no_capture_(no_capture) {}	5✔
92
93	MemoryAccessPatternType PointerFullWriteOnly::access_write_pattern() const {	2✔
94	if (size_.is_null()) {	2✔
NEW 95	return nullptr;	×
96	} else {	2✔
97	return ConvexAccessPattern::create(size_, true);	2✔
98	}	2✔
99	}	2✔
100
101	MemoryAccessPatternType PointerFullWriteOnly::access_read_pattern() const { return NoAccessPattern::instance(); }	2✔
102
NEW 103	void PointerFullWriteOnly::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
NEW 104	size_ = symbolic::subs(size_, old_expression, new_expression);	×
NEW 105	}	×
106
NEW 107	PointerAccessType PointerFullWriteOnly::clone() const {	×
NEW 108	return PointerAccessType(new PointerFullWriteOnly(size_, no_capture_));	×
NEW 109	}	×
110
111	void PointerFullWriteOnly::serialize_to_json(nlohmann::json& entry) {	1✔
112	serializer::JSONSerializer serializer;	1✔
113	entry["type"] = "PointerWriteOnly";	1✔
114	entry["size"] = serializer.expression(size_);	1✔
115	entry["no_capture"] = no_capture_;	1✔
116	}	1✔
117
118	PointerGenericAccess::
119	PointerGenericAccess(MemoryAccessPatternType read_pattern, MemoryAccessPatternType write_pattern, bool no_capture)
120	: read_pattern_(std::move(read_pattern)), write_pattern_(std::move(write_pattern)), no_capture_(no_capture) {}	3✔
121
122	MemoryAccessPatternType PointerGenericAccess::access_read_pattern() const {	1✔
123	return read_pattern_ ? read_pattern_->ref() : nullptr;	1✔
124	}	1✔
125
126	MemoryAccessPatternType PointerGenericAccess::access_write_pattern() const {	1✔
127	return write_pattern_ ? write_pattern_->ref() : nullptr;	1✔
128	}	1✔
129
130	bool PointerGenericAccess::may_contain_reads() const { return !read_pattern_ \|\| !read_pattern_->empty(); }	1✔
131
132	bool PointerGenericAccess::may_contain_writes() const { return !write_pattern_ \|\| !write_pattern_->empty(); }	1✔
133
NEW 134	void PointerGenericAccess::replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) {	×
NEW 135	if (read_pattern_) {	×
NEW 136	read_pattern_->replace(old_expression, new_expression);	×
NEW 137	}	×
NEW 138	if (write_pattern_) {	×
NEW 139	write_pattern_->replace(old_expression, new_expression);	×
NEW 140	}	×
NEW 141	}	×
142
NEW 143	PointerAccessType PointerGenericAccess::clone() const {	×
NEW 144	auto rd_patt_new = read_pattern_ ? read_pattern_->clone() : nullptr;	×
NEW 145	auto wr_patt_new = write_pattern_ ? write_pattern_->clone() : nullptr;	×
NEW 146	return PointerAccessType(new PointerGenericAccess(std::move(rd_patt_new), std::move(wr_patt_new), no_capture_));	×
NEW 147	}	×
148
149	void PointerGenericAccess::serialize_to_json(nlohmann::json& entry) {	1✔
150	entry["type"] = "PointerGenericAccess";	1✔
151	if (read_pattern_) {	1✔
152	read_pattern_->serialize_to_json(entry["read_pattern"]);	1✔
153	}	1✔
154	if (write_pattern_) {	1✔
155	write_pattern_->serialize_to_json(entry["write_pattern"]);	1✔
156	}	1✔
157	entry["no_capture"] = no_capture_;	1✔
158	}	1✔
159
NEW 160	PointerAccessType PointerInvalidate::clone() const { return PointerAccessType(new PointerInvalidate()); }	×
161
162	void PointerInvalidate::serialize_to_json(nlohmann::json& entry) { entry["type"] = "PointerInvalidate"; }	1✔
163
164	PointerAccessType PointerAccessMetaSerializer::deserialize(const nlohmann::json& entry) {	4✔
165	if (entry.is_null()) {	4✔
NEW 166	return nullptr;	×
167	} else {	4✔
168	auto type = entry.at("type").get<std::string>();	4✔
169
170	if (type == "PointerInvalidate") {	4✔
171	return PointerAccessMeta::create_invalidate();	1✔
172	} else if (type == "PointerReadOnly") {	3✔
173	return deserialize_read_only(entry);	1✔
174	} else if (type == "PointerWriteOnly") {	2✔
175	return deserialize_write_only(entry);	1✔
176	} else if (type == "PointerGenericAccess") {	1✔
177	return deserialize_generic(entry);	1✔
178	} else {	1✔
NEW 179	throw std::runtime_error("Unknown MemoryAccessPattern type: " + type);	×
NEW 180	}	×
181	}	4✔
182	}	4✔
183
184	std::vector<PointerAccessType> PointerAccessMetaSerializer::deserialize_list(nlohmann::json::const_reference list) {	4✔
185	std::vector<PointerAccessType> result;	4✔
186	for (const auto& entry : list) {	4✔
187	result.push_back(deserialize(entry));	4✔
188	}	4✔
189	return result;	4✔
190	}	4✔
191
192	std::vector<PointerAccessType> PointerAccessMetaSerializer::
193	deserialize_list(nlohmann::json::const_iterator key, const nlohmann::json& parent) {	3✔
194	if (key != parent.end()) {	3✔
195	return deserialize_list(*key);	3✔
196	} else {	3✔
NEW 197	return {};	×
NEW 198	}	×
199	}	3✔
200
201	PointerAccessType PointerAccessMetaSerializer::deserialize_read_only(nlohmann::json::const_reference entry) {	1✔
202	serializer::JSONSerializer serializer;	1✔
203	bool no_capture = entry.at("no_capture").get<bool>();	1✔
204	auto size = serializer.json_to_expr(entry.at("size"));	1✔
205	return PointerAccessMeta::create_read_only(size, no_capture);	1✔
206	}	1✔
207
208	PointerAccessType PointerAccessMetaSerializer::deserialize_write_only(nlohmann::json::const_reference entry) {	1✔
209	serializer::JSONSerializer serializer;	1✔
210	bool no_capture = entry.at("no_capture").get<bool>();	1✔
211	auto size = serializer.json_to_expr(entry.at("size"));	1✔
212	return PointerAccessMeta::create_full_write_only(size, no_capture);	1✔
213	}	1✔
214
215	PointerAccessType PointerAccessMetaSerializer::deserialize_generic(nlohmann::json::const_reference entry) {	1✔
216	auto read_pattern = deserialize_access_pattern(entry.at("read_pattern"));	1✔
217	auto write_pattern = deserialize_access_pattern(entry.at("write_pattern"));	1✔
218	bool no_capture = entry.at("no_capture").get<bool>();	1✔
219	return PointerAccessMeta::create_generic(std::move(read_pattern), std::move(write_pattern), no_capture);	1✔
220	}	1✔
221
222	MemoryAccessPatternType PointerAccessMetaSerializer::deserialize_convex_pattern(nlohmann::json::const_reference entry) {	1✔
223	serializer::JSONSerializer serializer;	1✔
224	auto size = serializer.json_to_expr(entry.at("size"));	1✔
225	bool not_sparse = entry.at("not_sparse").get<bool>();	1✔
226	return ConvexAccessPattern::create(size, not_sparse);	1✔
227	}	1✔
228
229	MemoryAccessPatternType PointerAccessMetaSerializer::deserialize_access_pattern(nlohmann::json::const_reference entry) {	2✔
230	if (entry.is_null()) {	2✔
NEW 231	return nullptr;	×
232	} else {	2✔
233	auto type = entry.at("type").get<std::string>();	2✔
234	if (type == "NoAccessPattern") {	2✔
235	return NoAccessPattern::instance();	1✔
236	} else if (type == "ConvexAccessPattern") {	1✔
237	return deserialize_convex_pattern(entry);	1✔
238	} else {	1✔
NEW 239	throw std::runtime_error("Unknown MemoryAccessPattern type: " + type);	×
NEW 240	}	×
241	}	2✔
242	}	2✔
243
244	nlohmann::json PointerAccessMetaSerializer::serialize(const std::vector<PointerAccessType>& vector) {	4✔
245	auto arr = nlohmann::json::array();	4✔
246	for (const auto& entry : vector) {	4✔
247	nlohmann::json j;	4✔
248	entry->serialize_to_json(j);	4✔
249	arr.push_back(j);	4✔
250	}	4✔
251	return arr;	4✔
252	}	4✔
253
254	} // namespace sdfg::data_flow

daisytuner / docc / 26463753889

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous