13874105804

Committed 15 Mar 2025 03:15PM UTC coverage: 77.3% (+0.7%) from 76.638%

Build # 13874105804

Build Type

Pull #212

github

Committed by

web-flow

Commit Message

Merge eeeac26cd into 57989f91f

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

Run Details

26 of 38 new or added lines in 1 file covered. (68.42%)

4311 of 5577 relevant lines covered (77.3%)

221.92 hits per line

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

68.42

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

#include "optimizer/transform.hpp"

#include <memory>

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

vla5924-practice / compiler-project / 13874105804

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