summaryrefslogtreecommitdiff
path: root/src/apply-names.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/apply-names.cc')
-rw-r--r--src/apply-names.cc221
1 files changed, 117 insertions, 104 deletions
diff --git a/src/apply-names.cc b/src/apply-names.cc
index b61cd7f7..acfd511b 100644
--- a/src/apply-names.cc
+++ b/src/apply-names.cc
@@ -33,9 +33,13 @@ namespace wabt {
namespace {
-struct Context : ExprVisitor::DelegateNop {
- Context();
+class NameApplier : public ExprVisitor::DelegateNop {
+ public:
+ NameApplier();
+ Result VisitModule(Module* module);
+
+ // Implementation of ExprVisitor::DelegateNop.
Result BeginBlockExpr(Expr*) override;
Result EndBlockExpr(Expr*) override;
Result OnBrExpr(Expr*) override;
@@ -53,42 +57,57 @@ struct Context : ExprVisitor::DelegateNop {
Result OnSetLocalExpr(Expr*) override;
Result OnTeeLocalExpr(Expr*) override;
- Module* module = nullptr;
- Func* current_func = nullptr;
- ExprVisitor visitor;
+ private:
+ void PushLabel(Label* label);
+ void PopLabel();
+ Label* FindLabelByVar(Var* var);
+ void UseNameForVar(StringSlice* name, Var* var);
+ Result UseNameForFuncTypeVar(Module* module, Var* var);
+ Result UseNameForFuncVar(Module* module, Var* var);
+ Result UseNameForGlobalVar(Module* module, Var* var);
+ Result UseNameForTableVar(Module* module, Var* var);
+ Result UseNameForMemoryVar(Module* module, Var* var);
+ Result UseNameForParamAndLocalVar(Func* func, Var* var);
+ Result VisitFunc(Index func_index, Func* func);
+ Result VisitExport(Index export_index, Export* export_);
+ Result VisitElemSegment(Index elem_segment_index, ElemSegment* segment);
+ Result VisitDataSegment(Index data_segment_index, DataSegment* segment);
+
+ Module* module_ = nullptr;
+ Func* current_func_ = nullptr;
+ ExprVisitor visitor_;
/* mapping from param index to its name, if any, for the current func */
- std::vector<std::string> param_index_to_name;
- std::vector<std::string> local_index_to_name;
- std::vector<Label*> labels;
+ std::vector<std::string> param_index_to_name_;
+ std::vector<std::string> local_index_to_name_;
+ std::vector<Label*> labels_;
};
-Context::Context() : visitor(this) {
-}
+NameApplier::NameApplier() : visitor_(this) {}
-void push_label(Context* ctx, Label* label) {
- ctx->labels.push_back(label);
+void NameApplier::PushLabel(Label* label) {
+ labels_.push_back(label);
}
-void pop_label(Context* ctx) {
- ctx->labels.pop_back();
+void NameApplier::PopLabel() {
+ labels_.pop_back();
}
-Label* find_label_by_var(Context* ctx, Var* var) {
+Label* NameApplier::FindLabelByVar(Var* var) {
if (var->type == VarType::Name) {
- for (int i = ctx->labels.size() - 1; i >= 0; --i) {
- Label* label = ctx->labels[i];
+ for (int i = labels_.size() - 1; i >= 0; --i) {
+ Label* label = labels_[i];
if (string_slices_are_equal(label, &var->name))
return label;
}
return nullptr;
} else {
- if (var->index >= ctx->labels.size())
+ if (var->index >= labels_.size())
return nullptr;
- return ctx->labels[ctx->labels.size() - 1 - var->index];
+ return labels_[labels_.size() - 1 - var->index];
}
}
-void use_name_for_var(StringSlice* name, Var* var) {
+void NameApplier::UseNameForVar(StringSlice* name, Var* var) {
if (var->type == VarType::Name) {
assert(string_slices_are_equal(name, &var->name));
}
@@ -99,47 +118,47 @@ void use_name_for_var(StringSlice* name, Var* var) {
}
}
-Result use_name_for_func_type_var(Module* module, Var* var) {
+Result NameApplier::UseNameForFuncTypeVar(Module* module, Var* var) {
FuncType* func_type = get_func_type_by_var(module, var);
if (!func_type)
return Result::Error;
- use_name_for_var(&func_type->name, var);
+ UseNameForVar(&func_type->name, var);
return Result::Ok;
}
-Result use_name_for_func_var(Module* module, Var* var) {
+Result NameApplier::UseNameForFuncVar(Module* module, Var* var) {
Func* func = get_func_by_var(module, var);
if (!func)
return Result::Error;
- use_name_for_var(&func->name, var);
+ UseNameForVar(&func->name, var);
return Result::Ok;
}
-Result use_name_for_global_var(Module* module, Var* var) {
+Result NameApplier::UseNameForGlobalVar(Module* module, Var* var) {
Global* global = get_global_by_var(module, var);
if (!global)
return Result::Error;
- use_name_for_var(&global->name, var);
+ UseNameForVar(&global->name, var);
return Result::Ok;
}
-Result use_name_for_table_var(Module* module, Var* var) {
+Result NameApplier::UseNameForTableVar(Module* module, Var* var) {
Table* table = get_table_by_var(module, var);
if (!table)
return Result::Error;
- use_name_for_var(&table->name, var);
+ UseNameForVar(&table->name, var);
return Result::Ok;
}
-Result use_name_for_memory_var(Module* module, Var* var) {
+Result NameApplier::UseNameForMemoryVar(Module* module, Var* var) {
Memory* memory = get_memory_by_var(module, var);
if (!memory)
return Result::Error;
- use_name_for_var(&memory->name, var);
+ UseNameForVar(&memory->name, var);
return Result::Ok;
}
-Result use_name_for_param_and_local_var(Context* ctx, Func* func, Var* var) {
+Result NameApplier::UseNameForParamAndLocalVar(Func* func, Var* var) {
Index local_index = get_local_index_by_var(func, var);
if (local_index >= get_num_params_and_locals(func))
return Result::Error;
@@ -148,13 +167,13 @@ Result use_name_for_param_and_local_var(Context* ctx, Func* func, Var* var) {
std::string* name;
if (local_index < num_params) {
/* param */
- assert(local_index < ctx->param_index_to_name.size());
- name = &ctx->param_index_to_name[local_index];
+ assert(local_index < param_index_to_name_.size());
+ name = &param_index_to_name_[local_index];
} else {
/* local */
local_index -= num_params;
- assert(local_index < ctx->local_index_to_name.size());
- name = &ctx->local_index_to_name[local_index];
+ assert(local_index < local_index_to_name_.size());
+ name = &local_index_to_name_[local_index];
}
if (var->type == VarType::Name) {
@@ -170,159 +189,153 @@ Result use_name_for_param_and_local_var(Context* ctx, Func* func, Var* var) {
return Result::Ok;
}
-Result Context::BeginBlockExpr(Expr* expr) {
- push_label(this, &expr->block->label);
+Result NameApplier::BeginBlockExpr(Expr* expr) {
+ PushLabel(&expr->block->label);
return Result::Ok;
}
-Result Context::EndBlockExpr(Expr* expr) {
- pop_label(this);
+Result NameApplier::EndBlockExpr(Expr* expr) {
+ PopLabel();
return Result::Ok;
}
-Result Context::BeginLoopExpr(Expr* expr) {
- push_label(this, &expr->loop->label);
+Result NameApplier::BeginLoopExpr(Expr* expr) {
+ PushLabel(&expr->loop->label);
return Result::Ok;
}
-Result Context::EndLoopExpr(Expr* expr) {
- pop_label(this);
+Result NameApplier::EndLoopExpr(Expr* expr) {
+ PopLabel();
return Result::Ok;
}
-Result Context::OnBrExpr(Expr* expr) {
- Label* label = find_label_by_var(this, &expr->br.var);
- use_name_for_var(label, &expr->br.var);
+Result NameApplier::OnBrExpr(Expr* expr) {
+ Label* label = FindLabelByVar(&expr->br.var);
+ UseNameForVar(label, &expr->br.var);
return Result::Ok;
}
-Result Context::OnBrIfExpr(Expr* expr) {
- Label* label = find_label_by_var(this, &expr->br_if.var);
- use_name_for_var(label, &expr->br_if.var);
+Result NameApplier::OnBrIfExpr(Expr* expr) {
+ Label* label = FindLabelByVar(&expr->br_if.var);
+ UseNameForVar(label, &expr->br_if.var);
return Result::Ok;
}
-Result Context::OnBrTableExpr(Expr* expr) {
+Result NameApplier::OnBrTableExpr(Expr* expr) {
VarVector& targets = *expr->br_table.targets;
for (Var& target : targets) {
- Label* label = find_label_by_var(this, &target);
- use_name_for_var(label, &target);
+ Label* label = FindLabelByVar(&target);
+ UseNameForVar(label, &target);
}
- Label* label = find_label_by_var(this, &expr->br_table.default_target);
- use_name_for_var(label, &expr->br_table.default_target);
+ Label* label = FindLabelByVar(&expr->br_table.default_target);
+ UseNameForVar(label, &expr->br_table.default_target);
return Result::Ok;
}
-Result Context::OnCallExpr(Expr* expr) {
- CHECK_RESULT(use_name_for_func_var(module, &expr->call.var));
+Result NameApplier::OnCallExpr(Expr* expr) {
+ CHECK_RESULT(UseNameForFuncVar(module_, &expr->call.var));
return Result::Ok;
}
-Result Context::OnCallIndirectExpr(Expr* expr) {
- CHECK_RESULT(use_name_for_func_type_var(module, &expr->call_indirect.var));
+Result NameApplier::OnCallIndirectExpr(Expr* expr) {
+ CHECK_RESULT(UseNameForFuncTypeVar(module_, &expr->call_indirect.var));
return Result::Ok;
}
-Result Context::OnGetGlobalExpr(Expr* expr) {
- CHECK_RESULT(use_name_for_global_var(module, &expr->get_global.var));
+Result NameApplier::OnGetGlobalExpr(Expr* expr) {
+ CHECK_RESULT(UseNameForGlobalVar(module_, &expr->get_global.var));
return Result::Ok;
}
-Result Context::OnGetLocalExpr(Expr* expr) {
- CHECK_RESULT(use_name_for_param_and_local_var(this, current_func,
- &expr->get_local.var));
+Result NameApplier::OnGetLocalExpr(Expr* expr) {
+ CHECK_RESULT(UseNameForParamAndLocalVar(current_func_, &expr->get_local.var));
return Result::Ok;
}
-Result Context::BeginIfExpr(Expr* expr) {
- push_label(this, &expr->if_.true_->label);
+Result NameApplier::BeginIfExpr(Expr* expr) {
+ PushLabel(&expr->if_.true_->label);
return Result::Ok;
}
-Result Context::EndIfExpr(Expr* expr) {
- pop_label(this);
+Result NameApplier::EndIfExpr(Expr* expr) {
+ PopLabel();
return Result::Ok;
}
-Result Context::OnSetGlobalExpr(Expr* expr) {
- CHECK_RESULT(use_name_for_global_var(module, &expr->set_global.var));
+Result NameApplier::OnSetGlobalExpr(Expr* expr) {
+ CHECK_RESULT(UseNameForGlobalVar(module_, &expr->set_global.var));
return Result::Ok;
}
-Result Context::OnSetLocalExpr(Expr* expr) {
- CHECK_RESULT(use_name_for_param_and_local_var(this, current_func,
- &expr->set_local.var));
+Result NameApplier::OnSetLocalExpr(Expr* expr) {
+ CHECK_RESULT(UseNameForParamAndLocalVar(current_func_, &expr->set_local.var));
return Result::Ok;
}
-Result Context::OnTeeLocalExpr(Expr* expr) {
- CHECK_RESULT(use_name_for_param_and_local_var(this, current_func,
- &expr->tee_local.var));
+Result NameApplier::OnTeeLocalExpr(Expr* expr) {
+ CHECK_RESULT(UseNameForParamAndLocalVar(current_func_, &expr->tee_local.var));
return Result::Ok;
}
-Result visit_func(Context* ctx, Index func_index, Func* func) {
- ctx->current_func = func;
+Result NameApplier::VisitFunc(Index func_index, Func* func) {
+ current_func_ = func;
if (decl_has_func_type(&func->decl)) {
- CHECK_RESULT(use_name_for_func_type_var(ctx->module, &func->decl.type_var));
+ CHECK_RESULT(UseNameForFuncTypeVar(module_, &func->decl.type_var));
}
- make_type_binding_reverse_mapping(func->decl.sig.param_types,
- func->param_bindings,
- &ctx->param_index_to_name);
+ make_type_binding_reverse_mapping(
+ func->decl.sig.param_types, func->param_bindings, &param_index_to_name_);
make_type_binding_reverse_mapping(func->local_types, func->local_bindings,
- &ctx->local_index_to_name);
+ &local_index_to_name_);
- CHECK_RESULT(ctx->visitor.VisitFunc(func));
- ctx->current_func = nullptr;
+ CHECK_RESULT(visitor_.VisitFunc(func));
+ current_func_ = nullptr;
return Result::Ok;
}
-Result visit_export(Context* ctx, Index export_index, Export* export_) {
+Result NameApplier::VisitExport(Index export_index, Export* export_) {
if (export_->kind == ExternalKind::Func) {
- use_name_for_func_var(ctx->module, &export_->var);
+ UseNameForFuncVar(module_, &export_->var);
}
return Result::Ok;
}
-Result visit_elem_segment(Context* ctx,
- Index elem_segment_index,
- ElemSegment* segment) {
- CHECK_RESULT(use_name_for_table_var(ctx->module, &segment->table_var));
+Result NameApplier::VisitElemSegment(Index elem_segment_index,
+ ElemSegment* segment) {
+ CHECK_RESULT(UseNameForTableVar(module_, &segment->table_var));
for (Var& var : segment->vars) {
- CHECK_RESULT(use_name_for_func_var(ctx->module, &var));
+ CHECK_RESULT(UseNameForFuncVar(module_, &var));
}
return Result::Ok;
}
-Result visit_data_segment(Context* ctx,
- Index data_segment_index,
- DataSegment* segment) {
- CHECK_RESULT(use_name_for_memory_var(ctx->module, &segment->memory_var));
+Result NameApplier::VisitDataSegment(Index data_segment_index,
+ DataSegment* segment) {
+ CHECK_RESULT(UseNameForMemoryVar(module_, &segment->memory_var));
return Result::Ok;
}
-Result visit_module(Context* ctx, Module* module) {
+Result NameApplier::VisitModule(Module* module) {
+ module_ = module;
for (size_t i = 0; i < module->funcs.size(); ++i)
- CHECK_RESULT(visit_func(ctx, i, module->funcs[i]));
+ CHECK_RESULT(VisitFunc(i, module->funcs[i]));
for (size_t i = 0; i < module->exports.size(); ++i)
- CHECK_RESULT(visit_export(ctx, i, module->exports[i]));
+ CHECK_RESULT(VisitExport(i, module->exports[i]));
for (size_t i = 0; i < module->elem_segments.size(); ++i)
- CHECK_RESULT(visit_elem_segment(ctx, i, module->elem_segments[i]));
+ CHECK_RESULT(VisitElemSegment(i, module->elem_segments[i]));
for (size_t i = 0; i < module->data_segments.size(); ++i)
- CHECK_RESULT(visit_data_segment(ctx, i, module->data_segments[i]));
+ CHECK_RESULT(VisitDataSegment(i, module->data_segments[i]));
+ module_ = nullptr;
return Result::Ok;
}
} // namespace
Result apply_names(Module* module) {
- Context ctx;
- ctx.module = module;
- Result result = visit_module(&ctx, module);
- return result;
+ NameApplier applier;
+ return applier.VisitModule(module);
}
} // namespace wabt
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-26 18:39:07 +0000