IRInliner.hpp

Go to the documentation of this file.

/**
 * @file IRInliner.hpp
 * @author Lexy Plateau (lexplt.dev@gmail.com)
 * @brief Try to inline IR blocks
 * @date 2026-07-11
 *
 * @copyright Copyright (c) 2026
 *
 */
 
#ifndef ARK_COMPILER_INTERMEDIATEREPRESENTATION_IRINLINER_HPP
#define ARK_COMPILER_INTERMEDIATEREPRESENTATION_IRINLINER_HPP
 
#include <Ark/Utils/Platform.hpp>
#include <Ark/Compiler/Pass.hpp>
#include <Ark/Compiler/ValTableElem.hpp>
#include <Ark/Compiler/IntermediateRepresentation/Entity.hpp>
 
#include <utility>
#include <vector>
#include <string>
 
namespace Ark::internal
{
    struct BlockInfo
    {
        long constant_id;
        std::size_t addr;
        std::string name;
        std::optional<std::size_t> symbol_id;
    };
 
    struct SymbolData
    {
        std::string name;
        std::size_t declarations_count;
        std::size_t use_count;
    };
 
    class ARK_API IRInliner final : public Pass
    {
    public:
        /**
         * @brief Create a new IRInliner
         *
         * @param debug debug level
         */
        explicit IRInliner(unsigned debug);
 
        /**
         * @brief Attempt to inline IR blocks to avoid function calls when possible
         *
         * @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
         * @param last_label last label generated by the AST lowerer
         */
        void process(const std::vector<IR::Block>& pages, const std::vector<std::string>& symbols, const std::vector<ValTableElem>& values, IR::label_t last_label);
 
        /**
         * @brief Return the IR blocks (one per scope)
         *
         * @return const std::vector<Block>&
         */
        [[nodiscard]] const std::vector<IR::Block>& intermediateRepresentation() const noexcept;
 
    private:
        std::vector<IR::Block> m_ir;
        std::vector<std::string> m_symbols;
        std::vector<ValTableElem> m_values;
        std::vector<BlockInfo> m_funcs;
        std::unordered_map<long, SymbolData> m_symbols_data;
        IR::label_t m_current_label;
 
        enum class CallKind
        {
            Symbol,
            Constant
        };
 
        /**
         * @brief Check if a block can be inlined in another one
         *
         * @param candidate block to inline
         * @param source where the inlining will take place
         * @param argc argument count in source to candidate
         * @return true if the candidate can be inlined
         */
        [[nodiscard]] static bool canBeInlined(const IR::Block& candidate, const IR::Block& source, std::size_t argc) noexcept;
 
        /**
         * @brief See if a block can be inlined in the current call site
         *
         * @param kind kind of call instruction being used (by symbol or constant)
         * @param pages
         * @param maybe_id optional identifier of a block (constant id or symbol id)
         * @param current current block where inlining could take place
         * @param argc argument count in source to candidate
         * @return std::optional<BlockInfo> candidate to inlining
         */
        [[nodiscard]] std::optional<BlockInfo> blockToInlineInCall(CallKind kind, const std::vector<IR::Block>& pages, std::optional<uint16_t> maybe_id, const IR::Block& current, std::size_t argc) const noexcept;
 
        /**
         * @brief Check if an IR block represents a builtin proxy, and return its CALL instruction if it is
         *
         * @param block IR block
         * @return std::optional<IR::Entity>
         */
        [[nodiscard]] static std::optional<IR::Entity> isBuiltinProxy(const IR::Block& block);
 
        /**
         * @brief Perform the inlining
         *
         * @param inlinee IR block to inline
         * @param destination new IR block to write instructions to
         */
        void inlineBlock(const IR::Block& inlinee, IR::Block& destination);
 
        /**
         * @brief Extract metadata from the IR entities pages, to have a name, constant id, and potentially symbol id per page
         *
         * @param pages pages of IR entities
         */
        void extractPagesMetadata(const std::vector<IR::Block>& pages);
 
        /**
         * @brief Search for a block by one of its IDs
         *
         * @param kind kind of call instruction being used (by symbol or constant)
         * @param id
         * @return std::optional<BlockInfo>
         */
        [[nodiscard]] std::optional<BlockInfo> findBlockBy(CallKind kind, uint16_t id) const noexcept;
    };
}
 
#endif  // ARK_COMPILER_INTERMEDIATEREPRESENTATION_IRINLINER_HPP