13884489619

Committed 16 Mar 2025 02:44PM UTC coverage: 77.883% (+1.2%) from 76.638%

Build # 13884489619

Build Type

Pull #212

github

Committed by

web-flow

Commit Message

Merge 37571da47 into 9f356f9ca

Pull Request Pull Request #212: Implement fold control flow optimization

Run Details

25 of 37 new or added lines in 1 file covered. (67.57%)

323 existing lines in 11 files now uncovered.

4437 of 5697 relevant lines covered (77.88%)

250.1 hits per line

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

67.57

/compiler/lib/backend/optree/optimizer/transforms/fold_control_flow_ops.cpp

#include "optimizer/transform.hpp"

#include <memory>
#include <string_view>

#include "compiler/optree/adaptors.hpp"
#include "compiler/optree/helpers.hpp"
#include "compiler/optree/operation.hpp"
#include "compiler/utils/helpers.hpp"

#include "optimizer/opt_builder.hpp"

using namespace optree;
using namespace optree::optimizer;

namespace {

struct FoldControlFlowOps : public Transform<IfOp, WhileOp> {
    using Transform::Transform;

    std::string_view name() const override {
        return "FoldControlFlowOps";
    }

    static void hoistBody(const Operation::Ptr &op, OptBuilder &builder) {
        if (!op)
            return;
        builder.setInsertPointBefore(op->parent);
        for (const auto &childOp : utils::advanceEarly(op->body)) {
            auto cloned = builder.clone(childOp);
            builder.replace(childOp, cloned);
            builder.setInsertPointAfter(cloned);
        }
    }

    static void processIfOp(const IfOp &op, OptBuilder &builder) {
        auto conditionOp = getValueOwnerAs<ConstantOp>(op.cond());
        if (!conditionOp)
            return;
        bool condition = conditionOp.value().as<bool>();
        if (condition) {
            hoistBody(op.thenOp(), builder);
        } else {
            hoistBody(op.elseOp(), builder);
        }
        builder.erase(op);
    }

    static void processWhileOp(const WhileOp &op, OptBuilder &builder) {
        auto conditionOp = getValueOwnerAs<ConstantOp>(op.conditionOp().terminator());
        if (!conditionOp)
            return;
        bool condition = conditionOp.value().as<bool>();
        if (!condition) {
            builder.erase(op);
        }
    }

    void run(const Operation::Ptr &op, OptBuilder &builder) const override {
        if (auto ifOp = op->as<IfOp>())
            processIfOp(ifOp, builder);
        else if (auto whileOp = op->as<WhileOp>())
            processWhileOp(whileOp, builder);
    }
};

} // namespace

namespace optree {
namespace optimizer {

BaseTransform::Ptr createFoldControlFlowOps() {
    return std::make_shared<FoldControlFlowOps>();
}

} // namespace optimizer
} // namespace optree

1	#include "optimizer/transform.hpp"
2
3	#include <memory>
4	#include <string_view>
5
6	#include "compiler/optree/adaptors.hpp"
7	#include "compiler/optree/helpers.hpp"
8	#include "compiler/optree/operation.hpp"
9	#include "compiler/utils/helpers.hpp"
10
11	#include "optimizer/opt_builder.hpp"
12
13	using namespace optree;
14	using namespace optree::optimizer;
15
16	namespace {
17
18	struct FoldControlFlowOps : public Transform<IfOp, WhileOp> {
19	using Transform::Transform;
20
21	std::string_view name() const override {	1✔
22	return "FoldControlFlowOps";	1✔
23	}
24
25	static void hoistBody(const Operation::Ptr &op, OptBuilder &builder) {	1✔
26	if (!op)	1✔
NEW 27	return;	×
28	builder.setInsertPointBefore(op->parent);	1✔
29	for (const auto &childOp : utils::advanceEarly(op->body)) {	3✔
30	auto cloned = builder.clone(childOp);	2✔
31	builder.replace(childOp, cloned);	2✔
32	builder.setInsertPointAfter(cloned);	2✔
33	}	2✔
34	}
35
36	static void processIfOp(const IfOp &op, OptBuilder &builder) {	1✔
37	auto conditionOp = getValueOwnerAs<ConstantOp>(op.cond());	1✔
38	if (!conditionOp)	1✔
NEW 39	return;	×
40	bool condition = conditionOp.value().as<bool>();	1✔
41	if (condition) {	1✔
42	hoistBody(op.thenOp(), builder);	1✔
43	} else {
NEW 44	hoistBody(op.elseOp(), builder);	×
45	}
46	builder.erase(op);	1✔
47	}	1✔
48
NEW 49	static void processWhileOp(const WhileOp &op, OptBuilder &builder) {	×
NEW 50	auto conditionOp = getValueOwnerAs<ConstantOp>(op.conditionOp().terminator());	×
NEW 51	if (!conditionOp)	×
NEW 52	return;	×
NEW 53	bool condition = conditionOp.value().as<bool>();	×
NEW 54	if (!condition) {	×
NEW 55	builder.erase(op);	×
56	}
NEW 57	}	×
58
59	void run(const Operation::Ptr &op, OptBuilder &builder) const override {	1✔
60	if (auto ifOp = op->as<IfOp>())	1✔
61	processIfOp(ifOp, builder);	1✔
NEW 62	else if (auto whileOp = op->as<WhileOp>())	×
63	processWhileOp(whileOp, builder);	1✔
64	}	1✔
65	};
66
67	} // namespace
68
69	namespace optree {
70	namespace optimizer {
71
72	BaseTransform::Ptr createFoldControlFlowOps() {	2✔
73	return std::make_shared<FoldControlFlowOps>();	2✔
74	}
75
76	} // namespace optimizer
77	} // namespace optree

vla5924-practice / compiler-project / 13884489619

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