IROptimizer.hpp

Go to the documentation of this file.

/**
 * @file IROptimizer.hpp
 * @author Lex Plateau (lexplt.dev@gmail.com)
 * @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/Utils/Platform.hpp>
#include <Ark/Utils/Logger.hpp>
#include <Ark/Compiler/ValTableElem.hpp>
#include <Ark/Compiler/IntermediateRepresentation/Entity.hpp>
 
#include <span>
#include <optional>
#include <functional>
 
namespace Ark::internal
{
    struct EntityWithOffset
    {
        IR::Entity entity;
        std::size_t offset;
    };
 
    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::span<const IR::Entity>;
        using Condition_t = std::function<bool(const Entities, const std::size_t)>;
        using Replacement_t = std::function<IR::Entity(const Entities)>;
 
        struct Rule
        {
            std::vector<Instruction> expected;
            Condition_t condition;            ///< Additional condition to match
            Replacement_t createReplacement;  ///< Create the replacement instructions from given context
 
            constexpr static auto default_cond = [](const Entities, const std::size_t) {
                return true;
            };
 
            Rule(std::vector<Instruction>&& input, Instruction replacement, Condition_t&& cond = default_cond) :
                expected(std::move(input)), condition(std::move(cond))
            {
                createReplacement = [replacement](const Entities e) {
                    return IR::Entity(replacement, e[0].primaryArg(), e[1].primaryArg());
                };
            }
 
            Rule(std::vector<Instruction>&& input, Condition_t&& cond, Replacement_t&& repl) :
                expected(std::move(input)), condition(std::move(cond)), createReplacement(std::move(repl))
            {}
 
            Rule(std::vector<Instruction>&& input, Replacement_t&& repl) :
                expected(std::move(input)), condition(default_cond), createReplacement(std::move(repl))
            {}
        };
 
        std::vector<Rule> m_ruleset;
 
        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, std::span<const IR::Entity> entities) const;
        [[nodiscard]] bool canBeOptimizedSafely(std::span<const IR::Entity> entities, std::size_t window_size) const;
        std::optional<EntityWithOffset> replaceWithRules(std::span<const IR::Entity> entities, const std::size_t position_in_block);
 
        [[nodiscard]] bool isPositiveNumberInlinable(uint16_t id) const;
        [[nodiscard]] bool isSmallerNumberInlinable(uint16_t id) const;
        [[nodiscard]] bool isNumberEqualTo(uint16_t id, int number) const;
        [[nodiscard]] uint16_t numberAsArg(uint16_t id) const;
        [[nodiscard]] uint16_t smallerNumberAsArg(uint16_t id) const;
    };
}
 
#endif  // ARK_COMPILER_INTERMEDIATEREPRESENTATION_IROPTIMIZER_HPP