IROptimizer.hpp

Go to the documentation of this file.

/**
 * @file IROptimizer.hpp
 * @author Alexandre Plateau ([email protected])
 * @brief Optimize IR based on IR entity grouped by 2 (or more)
 * @date 2024-10-11
 *
 * @copyright Copyright (c) 2024-2025
 *
 */
#ifndef ARK_COMPILER_INTERMEDIATEREPRESENTATION_IROPTIMIZER_HPP
#define ARK_COMPILER_INTERMEDIATEREPRESENTATION_IROPTIMIZER_HPP
 
#include <Ark/Platform.hpp>
#include <Ark/Logger.hpp>
#include <Ark/Compiler/ValTableElem.hpp>
#include <Ark/Compiler/IntermediateRepresentation/Entity.hpp>
 
#include <optional>
#include <functional>
 
namespace Ark::internal
{
    class ARK_API IROptimizer final
    {
    public:
        /**
         * @brief Create a new IROptimizer
         *
         * @param debug debug level
         */
        explicit IROptimizer(unsigned debug);
 
        /**
         * @brief Turn a given IR into bytecode
         *
         * @param pages list of lists of IR entities generated by the compiler
         * @param symbols symbol table generated by the compiler
         * @param values value table generated by the compiler
         */
        void process(const std::vector<IR::Block>& pages, const std::vector<std::string>& symbols, const std::vector<ValTableElem>& values);
 
        /**
         * @brief Return the IR blocks (one per scope)
         *
         * @return const std::vector<Block>&
         */
        [[nodiscard]] const std::vector<IR::Block>& intermediateRepresentation() const noexcept;
 
    private:
        using Entities = std::vector<IR::Entity>;
        using DualArgs = std::pair<uint16_t, uint16_t>;
 
        struct Rule
        {
            std::vector<Instruction> expected;
            Instruction replacement;
            std::function<bool(const Entities&)> condition = [](const Entities&) {
                return true;
            };  ///< Additional condition to match
            std::function<DualArgs(const Entities&)> createReplacement =
                [](const Entities& entities) {
                    return std::make_pair(entities[0].primaryArg(), entities[1].primaryArg());
                };  ///< Create the replacement instructions from given context
        };
 
        std::vector<Rule> m_ruleset_two;
        std::vector<Rule> m_ruleset_three;
 
        Logger m_logger;
        std::vector<IR::Block> m_ir;
        std::vector<std::string> m_symbols;
        std::vector<ValTableElem> m_values;
 
        [[nodiscard]] bool match(const std::vector<Instruction>& expected_insts, const Entities& entities) const;
        std::optional<IR::Entity> replaceWithRules(const std::vector<Rule>& rules, const Entities& entities);
 
        [[nodiscard]] bool isPositiveNumberInlinable(uint16_t id) const;
        [[nodiscard]] uint16_t numberAsArg(uint16_t id) const;
    };
}
 
#endif  // ARK_COMPILER_INTERMEDIATEREPRESENTATION_IROPTIMIZER_HPP