mirror of
https://github.com/ton-blockchain/ton
synced 2025-03-09 15:40:10 +00:00
[Tolk] Tolk v0.5.0 as FunC v0.5.0 could have been like
All changes from PR "FunC v0.5.0": https://github.com/ton-blockchain/ton/pull/1026 Instead of developing FunC, we decided to fork it. BTW, the first Tolk release will be v0.6, a metaphor of FunC v0.5 that missed a chance to occur.
This commit is contained in:
tolk-vm
parent
82648ebd6a
commit
ebbab54cda
21 changed files with 1345 additions and 789 deletions
155
tolk/tolk.cpp
155
tolk/tolk.cpp
|
|
@ -38,9 +38,74 @@ bool stack_layout_comments, op_rewrite_comments, program_envelope, asm_preamble;
|
|||
bool interactive = false;
|
||||
GlobalPragma pragma_allow_post_modification{"allow-post-modification"};
|
||||
GlobalPragma pragma_compute_asm_ltr{"compute-asm-ltr"};
|
||||
GlobalPragma pragma_remove_unused_functions{"remove-unused-functions"};
|
||||
std::string generated_from, boc_output_filename;
|
||||
ReadCallback::Callback read_callback;
|
||||
|
||||
// returns argument type of a function
|
||||
// note, that when a function has multiple arguments, its arg type is a tensor (no arguments — an empty tensor)
|
||||
// in other words, `f(int a, int b)` and `f((int,int) ab)` is the same when we speak about types
|
||||
const TypeExpr *SymValFunc::get_arg_type() const {
|
||||
if (!sym_type)
|
||||
return nullptr;
|
||||
|
||||
tolk_assert(sym_type->constr == TypeExpr::te_Map || sym_type->constr == TypeExpr::te_ForAll);
|
||||
const TypeExpr *te_map = sym_type->constr == TypeExpr::te_ForAll ? sym_type->args[0] : sym_type;
|
||||
const TypeExpr *arg_type = te_map->args[0];
|
||||
|
||||
while (arg_type->constr == TypeExpr::te_Indirect) {
|
||||
arg_type = arg_type->args[0];
|
||||
}
|
||||
return arg_type;
|
||||
}
|
||||
|
||||
|
||||
bool SymValCodeFunc::does_need_codegen() const {
|
||||
// when a function is declared, but not referenced from code in any way, don't generate its body
|
||||
if (!is_really_used && pragma_remove_unused_functions.enabled()) {
|
||||
return false;
|
||||
}
|
||||
// when a function is referenced like `var a = some_fn;` (or in some other non-call way), its continuation should exist
|
||||
if (flags & flagUsedAsNonCall) {
|
||||
return true;
|
||||
}
|
||||
// when a function f() is just `return anotherF(...args)`, it doesn't need to be codegenerated at all,
|
||||
// since all its usages are inlined
|
||||
return !is_just_wrapper_for_another_f();
|
||||
// in the future, we may want to implement a true AST inlining for `inline` functions also
|
||||
}
|
||||
|
||||
void GlobalPragma::enable(SrcLocation loc) {
|
||||
if (deprecated_from_v_) {
|
||||
loc.show_warning(PSTRING() << "#pragma " << name_ <<
|
||||
" is deprecated since Tolk v" << deprecated_from_v_ <<
|
||||
". Please, remove this line from your code.");
|
||||
return;
|
||||
}
|
||||
|
||||
enabled_ = true;
|
||||
locs_.push_back(std::move(loc));
|
||||
}
|
||||
|
||||
void GlobalPragma::check_enable_in_libs() {
|
||||
if (locs_.empty()) {
|
||||
return;
|
||||
}
|
||||
for (const SrcLocation& loc : locs_) {
|
||||
if (loc.fdescr->is_main) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
locs_[0].show_warning(PSTRING() << "#pragma " << name_
|
||||
<< " is enabled in included libraries, it may change the behavior of your code. "
|
||||
<< "Add this #pragma to the main source file to suppress this warning.");
|
||||
}
|
||||
|
||||
void GlobalPragma::always_on_and_deprecated(const char *deprecated_from_v) {
|
||||
deprecated_from_v_ = deprecated_from_v;
|
||||
enabled_ = true;
|
||||
}
|
||||
|
||||
td::Result<std::string> fs_read_callback(ReadCallback::Kind kind, const char* query) {
|
||||
switch (kind) {
|
||||
case ReadCallback::Kind::ReadFile: {
|
||||
|
|
@ -62,6 +127,55 @@ td::Result<std::string> fs_read_callback(ReadCallback::Kind kind, const char* qu
|
|||
}
|
||||
}
|
||||
|
||||
void mark_function_used_dfs(const std::unique_ptr<Op>& op);
|
||||
|
||||
void mark_function_used(SymValCodeFunc* func_val) {
|
||||
if (!func_val->code || func_val->is_really_used) { // already handled
|
||||
return;
|
||||
}
|
||||
|
||||
func_val->is_really_used = true;
|
||||
mark_function_used_dfs(func_val->code->ops);
|
||||
}
|
||||
|
||||
void mark_global_var_used(SymValGlobVar* glob_val) {
|
||||
glob_val->is_really_used = true;
|
||||
}
|
||||
|
||||
void mark_function_used_dfs(const std::unique_ptr<Op>& op) {
|
||||
if (!op) {
|
||||
return;
|
||||
}
|
||||
// op->fun_ref, despite its name, may actually ref global var
|
||||
// note, that for non-calls, e.g. `var a = some_fn` (Op::_Let), some_fn is Op::_GlobVar
|
||||
// (in other words, fun_ref exists not only for direct Op::_Call, but for non-call references also)
|
||||
if (op->fun_ref) {
|
||||
if (auto* func_val = dynamic_cast<SymValCodeFunc*>(op->fun_ref->value)) {
|
||||
mark_function_used(func_val);
|
||||
} else if (auto* glob_val = dynamic_cast<SymValGlobVar*>(op->fun_ref->value)) {
|
||||
mark_global_var_used(glob_val);
|
||||
} else if (auto* asm_val = dynamic_cast<SymValAsmFunc*>(op->fun_ref->value)) {
|
||||
} else {
|
||||
tolk_assert(false);
|
||||
}
|
||||
}
|
||||
mark_function_used_dfs(op->next);
|
||||
mark_function_used_dfs(op->block0);
|
||||
mark_function_used_dfs(op->block1);
|
||||
}
|
||||
|
||||
void mark_used_symbols() {
|
||||
for (SymDef* func_sym : glob_func) {
|
||||
auto* func_val = dynamic_cast<SymValCodeFunc*>(func_sym->value);
|
||||
std::string name = symbols.get_name(func_sym->sym_idx);
|
||||
if (func_val->method_id.not_null() ||
|
||||
name == "main" || name == "recv_internal" || name == "recv_external" ||
|
||||
name == "run_ticktock" || name == "split_prepare" || name == "split_install") {
|
||||
mark_function_used(func_val);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* OUTPUT CODE GENERATOR
|
||||
|
|
@ -76,8 +190,7 @@ void generate_output_func(SymDef* func_sym, std::ostream &outs, std::ostream &er
|
|||
errs << "\n\n=========================\nfunction " << name << " : " << func_val->get_type() << std::endl;
|
||||
}
|
||||
if (!func_val->code) {
|
||||
errs << "( function `" << name << "` undefined )\n";
|
||||
throw ParseError(func_sym->loc, name);
|
||||
throw ParseError(func_sym->loc, "function `" + name + "` is just declared, not implemented");
|
||||
} else {
|
||||
CodeBlob& code = *(func_val->code);
|
||||
if (verbosity >= 3) {
|
||||
|
|
@ -122,12 +235,10 @@ void generate_output_func(SymDef* func_sym, std::ostream &outs, std::ostream &er
|
|||
if (verbosity >= 2) {
|
||||
errs << "\n---------- resulting code for " << name << " -------------\n";
|
||||
}
|
||||
bool inline_func = (func_val->flags & 1);
|
||||
bool inline_ref = (func_val->flags & 2);
|
||||
const char* modifier = "";
|
||||
if (inline_func) {
|
||||
if (func_val->is_inline()) {
|
||||
modifier = "INLINE";
|
||||
} else if (inline_ref) {
|
||||
} else if (func_val->is_inline_ref()) {
|
||||
modifier = "REF";
|
||||
}
|
||||
outs << std::string(indent * 2, ' ') << name << " PROC" << modifier << ":<{\n";
|
||||
|
|
@ -138,12 +249,10 @@ void generate_output_func(SymDef* func_sym, std::ostream &outs, std::ostream &er
|
|||
if (opt_level < 2) {
|
||||
mode |= Stack::_DisableOpt;
|
||||
}
|
||||
auto fv = dynamic_cast<const SymValCodeFunc*>(func_sym->value);
|
||||
// Flags: 1 - inline, 2 - inline_ref
|
||||
if (fv && (fv->flags & 1) && code.ops->noreturn()) {
|
||||
if (func_val->is_inline() && code.ops->noreturn()) {
|
||||
mode |= Stack::_InlineFunc;
|
||||
}
|
||||
if (fv && (fv->flags & 3)) {
|
||||
if (func_val->is_inline() || func_val->is_inline_ref()) {
|
||||
mode |= Stack::_InlineAny;
|
||||
}
|
||||
code.generate_code(outs, mode, indent + 1);
|
||||
|
|
@ -162,9 +271,17 @@ int generate_output(std::ostream &outs, std::ostream &errs) {
|
|||
if (program_envelope) {
|
||||
outs << "PROGRAM{\n";
|
||||
}
|
||||
mark_used_symbols();
|
||||
for (SymDef* func_sym : glob_func) {
|
||||
SymValCodeFunc* func_val = dynamic_cast<SymValCodeFunc*>(func_sym->value);
|
||||
tolk_assert(func_val);
|
||||
if (!func_val->does_need_codegen()) {
|
||||
if (verbosity >= 2) {
|
||||
errs << func_sym->name() << ": code not generated, function does not need codegen\n";
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
std::string name = symbols.get_name(func_sym->sym_idx);
|
||||
outs << std::string(indent * 2, ' ');
|
||||
if (func_val->method_id.is_null()) {
|
||||
|
|
@ -174,12 +291,23 @@ int generate_output(std::ostream &outs, std::ostream &errs) {
|
|||
}
|
||||
}
|
||||
for (SymDef* gvar_sym : glob_vars) {
|
||||
tolk_assert(dynamic_cast<SymValGlobVar*>(gvar_sym->value));
|
||||
auto* glob_val = dynamic_cast<SymValGlobVar*>(gvar_sym->value);
|
||||
tolk_assert(glob_val);
|
||||
if (!glob_val->is_really_used && pragma_remove_unused_functions.enabled()) {
|
||||
if (verbosity >= 2) {
|
||||
errs << gvar_sym->name() << ": variable not generated, it's unused\n";
|
||||
}
|
||||
continue;
|
||||
}
|
||||
std::string name = symbols.get_name(gvar_sym->sym_idx);
|
||||
outs << std::string(indent * 2, ' ') << "DECLGLOBVAR " << name << "\n";
|
||||
}
|
||||
int errors = 0;
|
||||
for (SymDef* func_sym : glob_func) {
|
||||
SymValCodeFunc* func_val = dynamic_cast<SymValCodeFunc*>(func_sym->value);
|
||||
if (!func_val->does_need_codegen()) {
|
||||
continue;
|
||||
}
|
||||
try {
|
||||
generate_output_func(func_sym, outs, errs);
|
||||
} catch (Error& err) {
|
||||
|
|
@ -217,6 +345,8 @@ int tolk_proceed(const std::vector<std::string> &sources, std::ostream &outs, st
|
|||
|
||||
define_keywords();
|
||||
define_builtins();
|
||||
pragma_allow_post_modification.always_on_and_deprecated("0.5.0");
|
||||
pragma_compute_asm_ltr.always_on_and_deprecated("0.5.0");
|
||||
|
||||
int ok = 0, proc = 0;
|
||||
try {
|
||||
|
|
@ -235,8 +365,7 @@ int tolk_proceed(const std::vector<std::string> &sources, std::ostream &outs, st
|
|||
if (!proc) {
|
||||
throw Fatal{"no source files, no output"};
|
||||
}
|
||||
pragma_allow_post_modification.check_enable_in_libs();
|
||||
pragma_compute_asm_ltr.check_enable_in_libs();
|
||||
pragma_remove_unused_functions.check_enable_in_libs();
|
||||
return generate_output(outs, errs);
|
||||
} catch (Fatal& fatal) {
|
||||
errs << "fatal: " << fatal << std::endl;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue