mirror of
https://github.com/zeek/zeek.git
synced 2025-10-11 19:18:19 +00:00
78 lines
2.2 KiB
C++
78 lines
2.2 KiB
C++
// See the file "COPYING" in the main distribution directory for copyright.
|
|
|
|
// Class that manages the process of (recursively) inlining function bodies.
|
|
|
|
#pragma once
|
|
|
|
#include <unordered_set>
|
|
|
|
#include "zeek/Expr.h"
|
|
#include "zeek/Func.h"
|
|
#include "zeek/Scope.h"
|
|
|
|
namespace zeek::detail
|
|
{
|
|
|
|
class FuncInfo;
|
|
|
|
class Inliner
|
|
{
|
|
public:
|
|
// First argument is a collection of information about *all* of
|
|
// the script functions. Second argument states whether to report
|
|
// recursive functions (of interest as they're not in-lineable).
|
|
Inliner(std::vector<FuncInfo>& _funcs, bool _report_recursive)
|
|
: funcs(_funcs), report_recursive(_report_recursive)
|
|
{
|
|
Analyze();
|
|
}
|
|
|
|
// Either returns the original CallExpr if it's not inline-able;
|
|
// or an InlineExpr if it is; or nil if further inlining should stop.
|
|
ExprPtr CheckForInlining(CallExprPtr c);
|
|
|
|
// True if the given function has been inlined.
|
|
bool WasInlined(const Func* f)
|
|
{
|
|
return inline_ables.count(f) > 0 && skipped_inlining.count(f) == 0;
|
|
}
|
|
|
|
protected:
|
|
// Driver routine that analyzes all of the script functions and
|
|
// recursively inlines eligible ones.
|
|
void Analyze();
|
|
|
|
// Recursively inlines any calls associated with the given function.
|
|
void InlineFunction(FuncInfo* f);
|
|
|
|
// Information about all of the functions (and events/hooks) in
|
|
// the full set of scripts.
|
|
std::vector<FuncInfo>& funcs;
|
|
|
|
// Functions that we've determined to be suitable for inlining.
|
|
std::unordered_set<const Func*> inline_ables;
|
|
|
|
// Functions that we didn't fully inline, so require separate
|
|
// compilation.
|
|
std::unordered_set<const Func*> skipped_inlining;
|
|
|
|
// As we do inlining for a given function, this tracks the
|
|
// largest frame size of any inlined function.
|
|
int max_inlined_frame_size;
|
|
|
|
// The size of the frame of the currently-being-inlined function,
|
|
// prior to increasing it to accommodate inlining.
|
|
int curr_frame_size;
|
|
|
|
// The number of statements and expressions in the function being
|
|
// inlined. Dynamically updated as the inlining proceeds. Used
|
|
// to cap inlining complexity.
|
|
int num_stmts;
|
|
int num_exprs;
|
|
|
|
// Whether to generate a report about functions either directly and
|
|
// indirectly recursive.
|
|
bool report_recursive;
|
|
};
|
|
|
|
} // namespace zeek::detail
|