diff options
Diffstat (limited to 'Userland/Libraries')
10 files changed, 197 insertions, 197 deletions
diff --git a/Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.cpp b/Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.cpp index 34d53b1c54..bb7315afd8 100644 --- a/Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.cpp +++ b/Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.cpp @@ -11,7 +11,7 @@ namespace Wasm { -Optional<FunctionAddress> Store::allocate(ModuleInstance& module, const Module::Function& function) +Optional<FunctionAddress> Store::allocate(ModuleInstance& module, Module::Function const& function) { FunctionAddress address { m_functions.size() }; if (function.type().value() > module.types().size()) @@ -29,7 +29,7 @@ Optional<FunctionAddress> Store::allocate(HostFunction&& function) return address; } -Optional<TableAddress> Store::allocate(const TableType& type) +Optional<TableAddress> Store::allocate(TableType const& type) { TableAddress address { m_tables.size() }; Vector<Optional<Reference>> elements; @@ -38,21 +38,21 @@ Optional<TableAddress> Store::allocate(const TableType& type) return address; } -Optional<MemoryAddress> Store::allocate(const MemoryType& type) +Optional<MemoryAddress> Store::allocate(MemoryType const& type) { MemoryAddress address { m_memories.size() }; m_memories.empend(MemoryInstance { type }); return address; } -Optional<GlobalAddress> Store::allocate(const GlobalType& type, Value value) +Optional<GlobalAddress> Store::allocate(GlobalType const& type, Value value) { GlobalAddress address { m_globals.size() }; m_globals.append(GlobalInstance { move(value), type.is_mutable() }); return address; } -Optional<ElementAddress> Store::allocate(const ValueType& type, Vector<Reference> references) +Optional<ElementAddress> Store::allocate(ValueType const& type, Vector<Reference> references) { ElementAddress address { m_elements.size() }; m_elements.append(ElementInstance { type, move(references) }); @@ -99,13 +99,13 @@ ElementInstance* Store::get(ElementAddress address) return &m_elements[value]; } -InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<ExternValue> externs) +InstantiationResult AbstractMachine::instantiate(Module const& module, Vector<ExternValue> externs) { auto main_module_instance_pointer = make<ModuleInstance>(); auto& main_module_instance = *main_module_instance_pointer; Optional<InstantiationResult> instantiation_result; - module.for_each_section_of_type<TypeSection>([&](const TypeSection& section) { + module.for_each_section_of_type<TypeSection>([&](TypeSection const& section) { main_module_instance.types() = section.types(); }); @@ -147,7 +147,7 @@ InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<Ex if (auto result = allocate_all_initial_phase(module, main_module_instance, externs, global_values); result.has_value()) return result.release_value(); - module.for_each_section_of_type<ElementSection>([&](const ElementSection& section) { + module.for_each_section_of_type<ElementSection>([&](ElementSection const& section) { for (auto& segment : section.segments()) { Vector<Reference> references; for (auto& entry : segment.init) { @@ -190,7 +190,7 @@ InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<Ex if (auto result = allocate_all_final_phase(module, main_module_instance, elements); result.has_value()) return result.release_value(); - module.for_each_section_of_type<ElementSection>([&](const ElementSection& section) { + module.for_each_section_of_type<ElementSection>([&](ElementSection const& section) { size_t index = 0; for (auto& segment : section.segments()) { auto current_index = index; @@ -256,10 +256,10 @@ InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<Ex if (instantiation_result.has_value()) return instantiation_result.release_value(); - module.for_each_section_of_type<DataSection>([&](const DataSection& data_section) { + module.for_each_section_of_type<DataSection>([&](DataSection const& data_section) { for (auto& segment : data_section.data()) { segment.value().visit( - [&](const DataSection::Data::Active& data) { + [&](DataSection::Data::Active const& data) { Configuration config { m_store }; config.set_frame(Frame { main_module_instance, @@ -274,8 +274,8 @@ InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<Ex } size_t offset = 0; result.values().first().value().visit( - [&](const auto& value) { offset = value; }, - [&](const Reference&) { instantiation_result = InstantiationError { "Data segment offset returned a reference" }; }); + [&](auto const& value) { offset = value; }, + [&](Reference const&) { instantiation_result = InstantiationError { "Data segment offset returned a reference" }; }); if (instantiation_result.has_value() && instantiation_result->is_error()) return; if (main_module_instance.memories().size() <= data.index.value()) { @@ -293,13 +293,13 @@ InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<Ex instance->data().overwrite(offset, data.init.data(), data.init.size()); } }, - [&](const DataSection::Data::Passive&) { + [&](DataSection::Data::Passive const&) { // FIXME: What do we do here? }); } }); - module.for_each_section_of_type<StartSection>([&](const StartSection& section) { + module.for_each_section_of_type<StartSection>([&](StartSection const& section) { auto& functions = main_module_instance.functions(); auto index = section.function().index(); if (functions.size() <= index.value()) { @@ -315,16 +315,16 @@ InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<Ex return InstantiationResult { move(main_module_instance_pointer) }; } -Optional<InstantiationError> AbstractMachine::allocate_all_initial_phase(const Module& module, ModuleInstance& module_instance, Vector<ExternValue>& externs, Vector<Value>& global_values) +Optional<InstantiationError> AbstractMachine::allocate_all_initial_phase(Module const& module, ModuleInstance& module_instance, Vector<ExternValue>& externs, Vector<Value>& global_values) { Optional<InstantiationError> result; for (auto& entry : externs) { entry.visit( - [&](const FunctionAddress& address) { module_instance.functions().append(address); }, - [&](const TableAddress& address) { module_instance.tables().append(address); }, - [&](const MemoryAddress& address) { module_instance.memories().append(address); }, - [&](const GlobalAddress& address) { module_instance.globals().append(address); }); + [&](FunctionAddress const& address) { module_instance.functions().append(address); }, + [&](TableAddress const& address) { module_instance.tables().append(address); }, + [&](MemoryAddress const& address) { module_instance.memories().append(address); }, + [&](GlobalAddress const& address) { module_instance.globals().append(address); }); } // FIXME: What if this fails? @@ -335,7 +335,7 @@ Optional<InstantiationError> AbstractMachine::allocate_all_initial_phase(const M module_instance.functions().append(*address); } - module.for_each_section_of_type<TableSection>([&](const TableSection& section) { + module.for_each_section_of_type<TableSection>([&](TableSection const& section) { for (auto& table : section.tables()) { auto table_address = m_store.allocate(table.type()); VERIFY(table_address.has_value()); @@ -343,7 +343,7 @@ Optional<InstantiationError> AbstractMachine::allocate_all_initial_phase(const M } }); - module.for_each_section_of_type<MemorySection>([&](const MemorySection& section) { + module.for_each_section_of_type<MemorySection>([&](MemorySection const& section) { for (auto& memory : section.memories()) { auto memory_address = m_store.allocate(memory.type()); VERIFY(memory_address.has_value()); @@ -351,7 +351,7 @@ Optional<InstantiationError> AbstractMachine::allocate_all_initial_phase(const M } }); - module.for_each_section_of_type<GlobalSection>([&](const GlobalSection& section) { + module.for_each_section_of_type<GlobalSection>([&](GlobalSection const& section) { size_t index = 0; for (auto& entry : section.entries()) { auto address = m_store.allocate(entry.type(), move(global_values[index])); @@ -360,29 +360,29 @@ Optional<InstantiationError> AbstractMachine::allocate_all_initial_phase(const M index++; } }); - module.for_each_section_of_type<ExportSection>([&](const ExportSection& section) { + module.for_each_section_of_type<ExportSection>([&](ExportSection const& section) { for (auto& entry : section.entries()) { Variant<FunctionAddress, TableAddress, MemoryAddress, GlobalAddress, Empty> address { Empty {} }; entry.description().visit( - [&](const FunctionIndex& index) { + [&](FunctionIndex const& index) { if (module_instance.functions().size() > index.value()) address = FunctionAddress { module_instance.functions()[index.value()] }; else dbgln("Failed to export '{}', the exported address ({}) was out of bounds (min: 0, max: {})", entry.name(), index.value(), module_instance.functions().size()); }, - [&](const TableIndex& index) { + [&](TableIndex const& index) { if (module_instance.tables().size() > index.value()) address = TableAddress { module_instance.tables()[index.value()] }; else dbgln("Failed to export '{}', the exported address ({}) was out of bounds (min: 0, max: {})", entry.name(), index.value(), module_instance.tables().size()); }, - [&](const MemoryIndex& index) { + [&](MemoryIndex const& index) { if (module_instance.memories().size() > index.value()) address = MemoryAddress { module_instance.memories()[index.value()] }; else dbgln("Failed to export '{}', the exported address ({}) was out of bounds (min: 0, max: {})", entry.name(), index.value(), module_instance.memories().size()); }, - [&](const GlobalIndex& index) { + [&](GlobalIndex const& index) { if (module_instance.globals().size() > index.value()) address = GlobalAddress { module_instance.globals()[index.value()] }; else @@ -404,9 +404,9 @@ Optional<InstantiationError> AbstractMachine::allocate_all_initial_phase(const M return result; } -Optional<InstantiationError> AbstractMachine::allocate_all_final_phase(const Module& module, ModuleInstance& module_instance, Vector<Vector<Reference>>& elements) +Optional<InstantiationError> AbstractMachine::allocate_all_final_phase(Module const& module, ModuleInstance& module_instance, Vector<Vector<Reference>>& elements) { - module.for_each_section_of_type<ElementSection>([&](const ElementSection& section) { + module.for_each_section_of_type<ElementSection>([&](ElementSection const& section) { size_t index = 0; for (auto& segment : section.segments()) { auto address = m_store.allocate(segment.type, move(elements[index])); @@ -431,7 +431,7 @@ Result AbstractMachine::invoke(Interpreter& interpreter, FunctionAddress address return configuration.call(interpreter, address, move(arguments)); } -void Linker::link(const ModuleInstance& instance) +void Linker::link(ModuleInstance const& instance) { populate(); if (m_unresolved_imports.is_empty()) @@ -450,7 +450,7 @@ void Linker::link(const ModuleInstance& instance) m_unresolved_imports.remove(entry); } -void Linker::link(const HashMap<Linker::Name, ExternValue>& exports) +void Linker::link(HashMap<Linker::Name, ExternValue> const& exports) { populate(); if (m_unresolved_imports.is_empty()) @@ -498,7 +498,7 @@ void Linker::populate() // There better be at most one import section! bool already_seen_an_import_section = false; - m_module.for_each_section_of_type<ImportSection>([&](const ImportSection& section) { + m_module.for_each_section_of_type<ImportSection>([&](ImportSection const& section) { if (already_seen_an_import_section) { if (!m_error.has_value()) m_error = LinkError {}; diff --git a/Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.h b/Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.h index ee3edd66cd..f5a04db05d 100644 --- a/Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.h +++ b/Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.h @@ -130,7 +130,7 @@ public: } } - Value(const Value& value) + Value(Value const& value) : m_value(AnyValueType { value.m_value }) , m_type(value.m_type) { @@ -149,7 +149,7 @@ public: return *this; } - Value& operator=(const Value& value) + Value& operator=(Value const& value) { m_value = value.m_value; m_type = value.m_type; @@ -167,7 +167,7 @@ public: else if constexpr (!IsFloatingPoint<T> && IsSame<decltype(value), MakeSigned<T>>) result = value; }, - [&](const Reference& value) { + [&](Reference const& value) { if constexpr (IsSame<T, Reference>) { result = value; } else if constexpr (IsSame<T, Reference::Func>) { @@ -279,7 +279,7 @@ private: class WasmFunction { public: - explicit WasmFunction(const FunctionType& type, const ModuleInstance& module, const Module::Function& code) + explicit WasmFunction(FunctionType const& type, ModuleInstance const& module, Module::Function const& code) : m_type(type) , m_module(module) , m_code(code) @@ -292,13 +292,13 @@ public: private: FunctionType m_type; - const ModuleInstance& m_module; - const Module::Function& m_code; + ModuleInstance const& m_module; + Module::Function const& m_code; }; class HostFunction { public: - explicit HostFunction(AK::Function<Result(Configuration&, Vector<Value>&)> function, const FunctionType& type) + explicit HostFunction(AK::Function<Result(Configuration&, Vector<Value>&)> function, FunctionType const& type) : m_function(move(function)) , m_type(type) { @@ -316,7 +316,7 @@ using FunctionInstance = Variant<WasmFunction, HostFunction>; class TableInstance { public: - explicit TableInstance(const TableType& type, Vector<Optional<Reference>> elements) + explicit TableInstance(TableType const& type, Vector<Optional<Reference>> elements) : m_elements(move(elements)) , m_type(type) { @@ -328,12 +328,12 @@ public: private: Vector<Optional<Reference>> m_elements; - const TableType& m_type; + TableType const& m_type; }; class MemoryInstance { public: - explicit MemoryInstance(const MemoryType& type) + explicit MemoryInstance(MemoryType const& type) : m_type(type) { grow(m_type.limits().min() * Constants::page_size); @@ -360,7 +360,7 @@ public: } private: - const MemoryType& m_type; + MemoryType const& m_type; size_t m_size { 0 }; ByteBuffer m_data; }; @@ -406,12 +406,12 @@ class Store { public: Store() = default; - Optional<FunctionAddress> allocate(ModuleInstance& module, const Module::Function& function); + Optional<FunctionAddress> allocate(ModuleInstance& module, Module::Function const& function); Optional<FunctionAddress> allocate(HostFunction&&); - Optional<TableAddress> allocate(const TableType&); - Optional<MemoryAddress> allocate(const MemoryType&); - Optional<GlobalAddress> allocate(const GlobalType&, Value); - Optional<ElementAddress> allocate(const ValueType&, Vector<Reference>); + Optional<TableAddress> allocate(TableType const&); + Optional<MemoryAddress> allocate(MemoryType const&); + Optional<GlobalAddress> allocate(GlobalType const&, Value); + Optional<ElementAddress> allocate(ValueType const&, Vector<Reference>); FunctionInstance* get(FunctionAddress); TableInstance* get(TableAddress); @@ -445,7 +445,7 @@ private: class Frame { public: - explicit Frame(const ModuleInstance& module, Vector<Value> locals, const Expression& expression, size_t arity) + explicit Frame(ModuleInstance const& module, Vector<Value> locals, Expression const& expression, size_t arity) : m_module(module) , m_locals(move(locals)) , m_expression(expression) @@ -460,9 +460,9 @@ public: auto arity() const { return m_arity; } private: - const ModuleInstance& m_module; + ModuleInstance const& m_module; Vector<Value> m_locals; - const Expression& m_expression; + Expression const& m_expression; size_t m_arity { 0 }; }; @@ -492,7 +492,7 @@ public: explicit AbstractMachine() = default; // Load and instantiate a module, and link it into this interpreter. - InstantiationResult instantiate(const Module&, Vector<ExternValue>); + InstantiationResult instantiate(Module const&, Vector<ExternValue>); Result invoke(FunctionAddress, Vector<Value>); Result invoke(Interpreter&, FunctionAddress, Vector<Value>); @@ -500,8 +500,8 @@ public: auto& store() { return m_store; } private: - Optional<InstantiationError> allocate_all_initial_phase(const Module&, ModuleInstance&, Vector<ExternValue>&, Vector<Value>& global_values); - Optional<InstantiationError> allocate_all_final_phase(const Module&, ModuleInstance&, Vector<Vector<Reference>>& elements); + Optional<InstantiationError> allocate_all_initial_phase(Module const&, ModuleInstance&, Vector<ExternValue>&, Vector<Value>& global_values); + Optional<InstantiationError> allocate_all_final_phase(Module const&, ModuleInstance&, Vector<Vector<Reference>>& elements); Store m_store; }; @@ -513,16 +513,16 @@ public: ImportSection::Import::ImportDesc type; }; - explicit Linker(const Module& module) + explicit Linker(Module const& module) : m_module(module) { } // Link a module, the import 'module name' is ignored with this. - void link(const ModuleInstance&); + void link(ModuleInstance const&); // Link a bunch of qualified values, also matches 'module name'. - void link(const HashMap<Name, ExternValue>&); + void link(HashMap<Name, ExternValue> const&); auto& unresolved_imports() { @@ -535,7 +535,7 @@ public: private: void populate(); - const Module& m_module; + Module const& m_module; HashMap<Name, ExternValue> m_resolved_imports; HashTable<Name> m_unresolved_imports; Vector<Name> m_ordered_imports; @@ -547,6 +547,6 @@ private: template<> struct AK::Traits<Wasm::Linker::Name> : public AK::GenericTraits<Wasm::Linker::Name> { static constexpr bool is_trivial() { return false; } - static unsigned hash(const Wasm::Linker::Name& entry) { return pair_int_hash(entry.module.hash(), entry.name.hash()); } - static bool equals(const Wasm::Linker::Name& a, const Wasm::Linker::Name& b) { return a.name == b.name && a.module == b.module; } + static unsigned hash(Wasm::Linker::Name const& entry) { return pair_int_hash(entry.module.hash(), entry.name.hash()); } + static bool equals(Wasm::Linker::Name const& a, Wasm::Linker::Name const& b) { return a.name == b.name && a.module == b.module; } }; diff --git a/Userland/Libraries/LibWasm/AbstractMachine/Configuration.cpp b/Userland/Libraries/LibWasm/AbstractMachine/Configuration.cpp index 9823f2093e..8e93ca5af0 100644 --- a/Userland/Libraries/LibWasm/AbstractMachine/Configuration.cpp +++ b/Userland/Libraries/LibWasm/AbstractMachine/Configuration.cpp @@ -23,7 +23,7 @@ Optional<Label> Configuration::nth_label(size_t i) return {}; } -void Configuration::unwind(Badge<CallFrameHandle>, const CallFrameHandle& frame_handle) +void Configuration::unwind(Badge<CallFrameHandle>, CallFrameHandle const& frame_handle) { if (m_stack.size() == frame_handle.stack_size && frame_handle.frame_index == m_current_frame_index) return; @@ -92,18 +92,18 @@ void Configuration::dump_stack() Printer { memory_stream }.print(vs...); dbgln(format.view(), StringView(memory_stream.copy_into_contiguous_buffer()).trim_whitespace()); }; - for (const auto& entry : stack().entries()) { + for (auto const& entry : stack().entries()) { entry.visit( - [&](const Value& v) { + [&](Value const& v) { print_value(" {}", v); }, - [&](const Frame& f) { + [&](Frame const& f) { dbgln(" frame({})", f.arity()); for (auto& local : f.locals()) { print_value(" {}", local); } }, - [](const Label& l) { + [](Label const& l) { dbgln(" label({}) -> {}", l.arity(), l.continuation()); }); } diff --git a/Userland/Libraries/LibWasm/AbstractMachine/Configuration.h b/Userland/Libraries/LibWasm/AbstractMachine/Configuration.h index 166cbb761f..fa206c309c 100644 --- a/Userland/Libraries/LibWasm/AbstractMachine/Configuration.h +++ b/Userland/Libraries/LibWasm/AbstractMachine/Configuration.h @@ -57,7 +57,7 @@ public: Configuration& configuration; }; - void unwind(Badge<CallFrameHandle>, const CallFrameHandle&); + void unwind(Badge<CallFrameHandle>, CallFrameHandle const&); Result call(Interpreter&, FunctionAddress, Vector<Value> arguments); Result execute(Interpreter&); diff --git a/Userland/Libraries/LibWasm/AbstractMachine/Interpreter.cpp b/Userland/Libraries/LibWasm/AbstractMachine/Interpreter.cpp index 43115daddd..5e5a1b5455 100644 --- a/Userland/Libraries/LibWasm/AbstractMachine/Interpreter.cpp +++ b/Userland/Libraries/LibWasm/AbstractMachine/Interpreter.cpp @@ -73,7 +73,7 @@ void BytecodeInterpreter::branch_to_label(Configuration& configuration, LabelInd } template<typename ReadType, typename PushType> -void BytecodeInterpreter::load_and_push(Configuration& configuration, const Instruction& instruction) +void BytecodeInterpreter::load_and_push(Configuration& configuration, Instruction const& instruction) { auto& address = configuration.frame().module().memories().first(); auto memory = configuration.store().get(address); @@ -98,7 +98,7 @@ void BytecodeInterpreter::load_and_push(Configuration& configuration, const Inst configuration.stack().peek() = Value(static_cast<PushType>(read_value<ReadType>(slice))); } -void BytecodeInterpreter::store_to_memory(Configuration& configuration, const Instruction& instruction, ReadonlyBytes data) +void BytecodeInterpreter::store_to_memory(Configuration& configuration, Instruction const& instruction, ReadonlyBytes data) { auto& address = configuration.frame().module().memories().first(); auto memory = configuration.store().get(address); @@ -120,8 +120,8 @@ void BytecodeInterpreter::call_address(Configuration& configuration, FunctionAdd { auto instance = configuration.store().get(address); TRAP_IF_NOT(instance); - const FunctionType* type { nullptr }; - instance->visit([&](const auto& function) { type = &function.type(); }); + FunctionType const* type { nullptr }; + instance->visit([&](auto const& function) { type = &function.type(); }); TRAP_IF_NOT(type); TRAP_IF_NOT(configuration.stack().entries().size() > type->parameters().size()); Vector<Value> args; @@ -396,7 +396,7 @@ ALWAYS_INLINE static i32 ctz(T value) VERIFY_NOT_REACHED(); } -void BytecodeInterpreter::interpret(Configuration& configuration, InstructionPointer& ip, const Instruction& instruction) +void BytecodeInterpreter::interpret(Configuration& configuration, InstructionPointer& ip, Instruction const& instruction) { dbgln_if(WASM_TRACE_DEBUG, "Executing instruction {} at ip {}", instruction_name(instruction.opcode()), ip.value()); @@ -973,7 +973,7 @@ void BytecodeInterpreter::interpret(Configuration& configuration, InstructionPoi } } -void DebuggerBytecodeInterpreter::interpret(Configuration& configuration, InstructionPointer& ip, const Instruction& instruction) +void DebuggerBytecodeInterpreter::interpret(Configuration& configuration, InstructionPointer& ip, Instruction const& instruction) { if (pre_interpret_hook) { auto result = pre_interpret_hook(configuration, ip, instruction); diff --git a/Userland/Libraries/LibWasm/AbstractMachine/Interpreter.h b/Userland/Libraries/LibWasm/AbstractMachine/Interpreter.h index 803194b1e1..8b71016c2f 100644 --- a/Userland/Libraries/LibWasm/AbstractMachine/Interpreter.h +++ b/Userland/Libraries/LibWasm/AbstractMachine/Interpreter.h @@ -37,11 +37,11 @@ struct BytecodeInterpreter : public Interpreter { }; protected: - virtual void interpret(Configuration&, InstructionPointer&, const Instruction&); + virtual void interpret(Configuration&, InstructionPointer&, Instruction const&); void branch_to_label(Configuration&, LabelIndex); template<typename ReadT, typename PushT> - void load_and_push(Configuration&, const Instruction&); - void store_to_memory(Configuration&, const Instruction&, ReadonlyBytes data); + void load_and_push(Configuration&, Instruction const&); + void store_to_memory(Configuration&, Instruction const&, ReadonlyBytes data); void call_address(Configuration&, FunctionAddress); template<typename V, typename T> @@ -66,11 +66,11 @@ protected: struct DebuggerBytecodeInterpreter : public BytecodeInterpreter { virtual ~DebuggerBytecodeInterpreter() override = default; - Function<bool(Configuration&, InstructionPointer&, const Instruction&)> pre_interpret_hook; - Function<bool(Configuration&, InstructionPointer&, const Instruction&, const Interpreter&)> post_interpret_hook; + Function<bool(Configuration&, InstructionPointer&, Instruction const&)> pre_interpret_hook; + Function<bool(Configuration&, InstructionPointer&, Instruction const&, Interpreter const&)> post_interpret_hook; private: - virtual void interpret(Configuration&, InstructionPointer&, const Instruction&) override; + virtual void interpret(Configuration&, InstructionPointer&, Instruction const&) override; }; } diff --git a/Userland/Libraries/LibWasm/Parser/Parser.cpp b/Userland/Libraries/LibWasm/Parser/Parser.cpp index 0335dc0a20..370e9a6e76 100644 --- a/Userland/Libraries/LibWasm/Parser/Parser.cpp +++ b/Userland/Libraries/LibWasm/Parser/Parser.cpp @@ -11,7 +11,7 @@ namespace Wasm { -ParseError with_eof_check(const InputStream& stream, ParseError error_if_not_eof) +ParseError with_eof_check(InputStream const& stream, ParseError error_if_not_eof) { if (stream.unreliable_eof()) return ParseError::UnexpectedEof; @@ -1358,9 +1358,9 @@ ParseResult<Module> Module::parse(InputStream& stream) void Module::populate_sections() { - const FunctionSection* function_section { nullptr }; - for_each_section_of_type<FunctionSection>([&](const FunctionSection& section) { function_section = §ion; }); - for_each_section_of_type<CodeSection>([&](const CodeSection& section) { + FunctionSection const* function_section { nullptr }; + for_each_section_of_type<FunctionSection>([&](FunctionSection const& section) { function_section = §ion; }); + for_each_section_of_type<CodeSection>([&](CodeSection const& section) { // FIXME: This should be considered invalid once validation is implemented. if (!function_section) return; diff --git a/Userland/Libraries/LibWasm/Printer/Printer.cpp b/Userland/Libraries/LibWasm/Printer/Printer.cpp index 5923c6e546..1467545bc6 100644 --- a/Userland/Libraries/LibWasm/Printer/Printer.cpp +++ b/Userland/Libraries/LibWasm/Printer/Printer.cpp @@ -15,7 +15,7 @@ struct Names { static HashMap<OpCode, String> instruction_names; }; -String instruction_name(const OpCode& opcode) +String instruction_name(OpCode const& opcode) { return Names::instruction_names.get(opcode).value_or("<unknown>"); } @@ -26,7 +26,7 @@ void Printer::print_indent() m_stream.write_or_error(" "sv.bytes()); } -void Printer::print(const Wasm::BlockType& type) +void Printer::print(Wasm::BlockType const& type) { print_indent(); print("(type block "); @@ -51,7 +51,7 @@ void Printer::print(const Wasm::BlockType& type) VERIFY_NOT_REACHED(); } -void Printer::print(const Wasm::CodeSection& section) +void Printer::print(Wasm::CodeSection const& section) { print_indent(); print("(section code\n"); @@ -64,12 +64,12 @@ void Printer::print(const Wasm::CodeSection& section) print(")\n"); } -void Printer::print(const Wasm::CodeSection::Code& code) +void Printer::print(Wasm::CodeSection::Code const& code) { print(code.func()); } -void Printer::print(const Wasm::CustomSection& section) +void Printer::print(Wasm::CustomSection const& section) { print_indent(); print("(section custom\n"); @@ -84,7 +84,7 @@ void Printer::print(const Wasm::CustomSection& section) print(")\n"); } -void Printer::print(const Wasm::DataCountSection& section) +void Printer::print(Wasm::DataCountSection const& section) { print_indent(); print("(section data count\n"); @@ -97,7 +97,7 @@ void Printer::print(const Wasm::DataCountSection& section) print(")\n"); } -void Printer::print(const Wasm::DataSection& section) +void Printer::print(Wasm::DataSection const& section) { print_indent(); print("(section data\n"); @@ -110,14 +110,14 @@ void Printer::print(const Wasm::DataSection& section) print(")\n"); } -void Printer::print(const Wasm::DataSection::Data& data) +void Printer::print(Wasm::DataSection::Data const& data) { print_indent(); print("(data with value\n"); { TemporaryChange change { m_indent, m_indent + 1 }; data.value().visit( - [this](const DataSection::Data::Passive& value) { + [this](DataSection::Data::Passive const& value) { print_indent(); print("(passive init {}xu8 (", value.init.size()); bool first = true; @@ -130,7 +130,7 @@ void Printer::print(const Wasm::DataSection::Data& data) } print(")\n"); }, - [this](const DataSection::Data::Active& value) { + [this](DataSection::Data::Active const& value) { print_indent(); print("(active init {}xu8 (", value.init.size()); bool first = true; @@ -164,7 +164,7 @@ void Printer::print(const Wasm::DataSection::Data& data) print(")\n"); } -void Printer::print(const Wasm::ElementSection& section) +void Printer::print(Wasm::ElementSection const& section) { print_indent(); print("(section element\n"); @@ -177,7 +177,7 @@ void Printer::print(const Wasm::ElementSection& section) print(")\n"); } -void Printer::print(const Wasm::ElementSection::Element& element) +void Printer::print(Wasm::ElementSection::Element const& element) { print_indent(); print("(element "); @@ -199,7 +199,7 @@ void Printer::print(const Wasm::ElementSection::Element& element) print_indent(); print("(mode "); element.mode.visit( - [this](const ElementSection::Active& active) { + [this](ElementSection::Active const& active) { print("\n"); { TemporaryChange change { m_indent, m_indent + 1 }; @@ -213,13 +213,13 @@ void Printer::print(const Wasm::ElementSection::Element& element) } print_indent(); }, - [this](const ElementSection::Passive&) { print("passive"); }, - [this](const ElementSection::Declarative&) { print("declarative"); }); + [this](ElementSection::Passive const&) { print("passive"); }, + [this](ElementSection::Declarative const&) { print("declarative"); }); print(")\n"); } } -void Printer::print(const Wasm::ExportSection& section) +void Printer::print(Wasm::ExportSection const& section) { print_indent(); print("(section export\n"); @@ -232,7 +232,7 @@ void Printer::print(const Wasm::ExportSection& section) print(")\n"); } -void Printer::print(const Wasm::ExportSection::Export& entry) +void Printer::print(Wasm::ExportSection::Export const& entry) { print_indent(); print("(export `{}' as\n", entry.name()); @@ -240,23 +240,23 @@ void Printer::print(const Wasm::ExportSection::Export& entry) TemporaryChange change { m_indent, m_indent + 1 }; print_indent(); entry.description().visit( - [this](const FunctionIndex& index) { print("(function index {})\n", index.value()); }, - [this](const TableIndex& index) { print("(table index {})\n", index.value()); }, - [this](const MemoryIndex& index) { print("(memory index {})\n", index.value()); }, - [this](const GlobalIndex& index) { print("(global index {})\n", index.value()); }); + [this](FunctionIndex const& index) { print("(function index {})\n", index.value()); }, + [this](TableIndex const& index) { print("(table index {})\n", index.value()); }, + [this](MemoryIndex const& index) { print("(memory index {})\n", index.value()); }, + [this](GlobalIndex const& index) { print("(global index {})\n", index.value()); }); } print_indent(); print(")\n"); } -void Printer::print(const Wasm::Expression& expression) +void Printer::print(Wasm::Expression const& expression) { TemporaryChange change { m_indent, m_indent + 1 }; for (auto& instr : expression.instructions()) print(instr); } -void Printer::print(const Wasm::CodeSection::Func& func) +void Printer::print(Wasm::CodeSection::Func const& func) { print_indent(); print("(function\n"); @@ -283,7 +283,7 @@ void Printer::print(const Wasm::CodeSection::Func& func) print(")\n"); } -void Printer::print(const Wasm::FunctionSection& section) +void Printer::print(Wasm::FunctionSection const& section) { print_indent(); print("(section function\n"); @@ -298,7 +298,7 @@ void Printer::print(const Wasm::FunctionSection& section) print(")\n"); } -void Printer::print(const Wasm::FunctionType& type) +void Printer::print(Wasm::FunctionType const& type) { print_indent(); print("(type function\n"); @@ -330,7 +330,7 @@ void Printer::print(const Wasm::FunctionType& type) print(")\n"); } -void Printer::print(const Wasm::GlobalSection& section) +void Printer::print(Wasm::GlobalSection const& section) { print_indent(); print("(section global\n"); @@ -343,7 +343,7 @@ void Printer::print(const Wasm::GlobalSection& section) print(")\n"); } -void Printer::print(const Wasm::GlobalSection::Global& entry) +void Printer::print(Wasm::GlobalSection::Global const& entry) { print_indent(); print("(global\n"); @@ -373,7 +373,7 @@ void Printer::print(const Wasm::GlobalSection::Global& entry) print(")\n"); } -void Printer::print(const Wasm::GlobalType& type) +void Printer::print(Wasm::GlobalType const& type) { print_indent(); print("(type global {}mutable\n", type.is_mutable() ? "" : "im"); @@ -385,7 +385,7 @@ void Printer::print(const Wasm::GlobalType& type) print(")\n"); } -void Printer::print(const Wasm::ImportSection& section) +void Printer::print(Wasm::ImportSection const& section) { print_indent(); print("(section import\n"); @@ -398,15 +398,15 @@ void Printer::print(const Wasm::ImportSection& section) print(")\n"); } -void Printer::print(const Wasm::ImportSection::Import& import) +void Printer::print(Wasm::ImportSection::Import const& import) { print_indent(); print("(import `{}' from `{}' as\n", import.name(), import.module()); { TemporaryChange change { m_indent, m_indent + 1 }; import.description().visit( - [this](const auto& type) { print(type); }, - [this](const TypeIndex& index) { + [this](auto const& type) { print(type); }, + [this](TypeIndex const& index) { print_indent(); print("(type index {})\n", index.value()); }); @@ -415,7 +415,7 @@ void Printer::print(const Wasm::ImportSection::Import& import) print(")\n"); } -void Printer::print(const Wasm::Instruction& instruction) +void Printer::print(Wasm::Instruction const& instruction) { print_indent(); print("({}", instruction_name(instruction.opcode())); @@ -424,29 +424,29 @@ void Printer::print(const Wasm::Instruction& instruction) } else { print(" "); instruction.arguments().visit( - [&](const BlockType& type) { print(type); }, - [&](const DataIndex& index) { print("(data index {})", index.value()); }, - [&](const ElementIndex& index) { print("(element index {})", index.value()); }, - [&](const FunctionIndex& index) { print("(function index {})", index.value()); }, - [&](const GlobalIndex& index) { print("(global index {})", index.value()); }, - [&](const LabelIndex& index) { print("(label index {})", index.value()); }, - [&](const LocalIndex& index) { print("(local index {})", index.value()); }, - [&](const TableIndex& index) { print("(table index {})", index.value()); }, - [&](const Instruction::IndirectCallArgs& args) { print("(indirect (type index {}) (table index {}))", args.type.value(), args.table.value()); }, - [&](const Instruction::MemoryArgument& args) { print("(memory (align {}) (offset {}))", args.align, args.offset); }, - [&](const Instruction::StructuredInstructionArgs& args) { print("(structured (else {}) (end {}))", args.else_ip.has_value() ? String::number(args.else_ip->value()) : "(none)", args.end_ip.value()); }, - [&](const Instruction::TableBranchArgs&) { print("(table_branch ...)"); }, - [&](const Instruction::TableElementArgs& args) { print("(table_element (table index {}) (element index {}))", args.table_index.value(), args.element_index.value()); }, - [&](const Instruction::TableTableArgs& args) { print("(table_table (table index {}) (table index {}))", args.lhs.value(), args.rhs.value()); }, - [&](const ValueType& type) { print(type); }, - [&](const Vector<ValueType>&) { print("(types...)"); }, - [&](const auto& value) { print("{}", value); }); + [&](BlockType const& type) { print(type); }, + [&](DataIndex const& index) { print("(data index {})", index.value()); }, + [&](ElementIndex const& index) { print("(element index {})", index.value()); }, + [&](FunctionIndex const& index) { print("(function index {})", index.value()); }, + [&](GlobalIndex const& index) { print("(global index {})", index.value()); }, + [&](LabelIndex const& index) { print("(label index {})", index.value()); }, + [&](LocalIndex const& index) { print("(local index {})", index.value()); }, + [&](TableIndex const& index) { print("(table index {})", index.value()); }, + [&](Instruction::IndirectCallArgs const& args) { print("(indirect (type index {}) (table index {}))", args.type.value(), args.table.value()); }, + [&](Instruction::MemoryArgument const& args) { print("(memory (align {}) (offset {}))", args.align, args.offset); }, + [&](Instruction::StructuredInstructionArgs const& args) { print("(structured (else {}) (end {}))", args.else_ip.has_value() ? String::number(args.else_ip->value()) : "(none)", args.end_ip.value()); }, + [&](Instruction::TableBranchArgs const&) { print("(table_branch ...)"); }, + [&](Instruction::TableElementArgs const& args) { print("(table_element (table index {}) (element index {}))", args.table_index.value(), args.element_index.value()); }, + [&](Instruction::TableTableArgs const& args) { print("(table_table (table index {}) (table index {}))", args.lhs.value(), args.rhs.value()); }, + [&](ValueType const& type) { print(type); }, + [&](Vector<ValueType> const&) { print("(types...)"); }, + [&](auto const& value) { print("{}", value); }); print(")\n"); } } -void Printer::print(const Wasm::Limits& limits) +void Printer::print(Wasm::Limits const& limits) { print_indent(); print("(limits min={}", limits.min()); @@ -457,7 +457,7 @@ void Printer::print(const Wasm::Limits& limits) print(")\n"); } -void Printer::print(const Wasm::Locals& local) +void Printer::print(Wasm::Locals const& local) { print_indent(); print("(local x{} of type\n", local.n()); @@ -469,7 +469,7 @@ void Printer::print(const Wasm::Locals& local) print(")\n"); } -void Printer::print(const Wasm::MemorySection& section) +void Printer::print(Wasm::MemorySection const& section) { print_indent(); print("(section memory\n"); @@ -482,7 +482,7 @@ void Printer::print(const Wasm::MemorySection& section) print(")\n"); } -void Printer::print(const Wasm::MemorySection::Memory& memory) +void Printer::print(Wasm::MemorySection::Memory const& memory) { print_indent(); print("(memory\n"); @@ -494,7 +494,7 @@ void Printer::print(const Wasm::MemorySection::Memory& memory) print(")\n"); } -void Printer::print(const Wasm::MemoryType& type) +void Printer::print(Wasm::MemoryType const& type) { print_indent(); print("(type memory\n"); @@ -506,20 +506,20 @@ void Printer::print(const Wasm::MemoryType& type) print(")\n"); } -void Printer::print(const Wasm::Module& module) +void Printer::print(Wasm::Module const& module) { print_indent(); { TemporaryChange change { m_indent, m_indent + 1 }; print("(module\n"); for (auto& section : module.sections()) - section.visit([this](const auto& value) { print(value); }); + section.visit([this](auto const& value) { print(value); }); } print_indent(); print(")\n"); } -void Printer::print(const Wasm::Module::Function& func) +void Printer::print(Wasm::Module::Function const& func) { print_indent(); print("(function\n"); @@ -546,7 +546,7 @@ void Printer::print(const Wasm::Module::Function& func) print(")\n"); } -void Printer::print(const Wasm::StartSection& section) +void Printer::print(Wasm::StartSection const& section) { print_indent(); print("(section start\n"); @@ -558,13 +558,13 @@ void Printer::print(const Wasm::StartSection& section) print(")\n"); } -void Printer::print(const Wasm::StartSection::StartFunction& function) +void Printer::print(Wasm::StartSection::StartFunction const& function) { print_indent(); print("(start function index {})\n", function.index().value()); } -void Printer::print(const Wasm::TableSection& section) +void Printer::print(Wasm::TableSection const& section) { print_indent(); print("(section table\n"); @@ -577,7 +577,7 @@ void Printer::print(const Wasm::TableSection& section) print(")\n"); } -void Printer::print(const Wasm::TableSection::Table& table) +void Printer::print(Wasm::TableSection::Table const& table) { print_indent(); print("(table\n"); @@ -589,7 +589,7 @@ void Printer::print(const Wasm::TableSection::Table& table) print(")\n"); } -void Printer::print(const Wasm::TableType& type) +void Printer::print(Wasm::TableType const& type) { print_indent(); print("(type table min:{}", type.limits().min()); @@ -604,7 +604,7 @@ void Printer::print(const Wasm::TableType& type) print(")\n"); } -void Printer::print(const Wasm::TypeSection& section) +void Printer::print(Wasm::TypeSection const& section) { print_indent(); print("(section type\n"); @@ -617,22 +617,22 @@ void Printer::print(const Wasm::TypeSection& section) print(")\n"); } -void Printer::print(const Wasm::ValueType& type) +void Printer::print(Wasm::ValueType const& type) { print_indent(); print("(type {})\n", ValueType::kind_name(type.kind())); } -void Printer::print(const Wasm::Value& value) +void Printer::print(Wasm::Value const& value) { print_indent(); - print("{} ", value.value().visit([&]<typename T>(const T& value) { + print("{} ", value.value().visit([&]<typename T>(T const& value) { if constexpr (IsSame<Wasm::Reference, T>) return String::formatted( "addr({})", value.ref().visit( - [](const Wasm::Reference::Null&) { return String("null"); }, - [](const auto& ref) { return String::number(ref.address.value()); })); + [](Wasm::Reference::Null const&) { return String("null"); }, + [](auto const& ref) { return String::number(ref.address.value()); })); else return String::formatted("{}", value); })); @@ -640,14 +640,14 @@ void Printer::print(const Wasm::Value& value) print(value.type()); } -void Printer::print(const Wasm::Reference& value) +void Printer::print(Wasm::Reference const& value) { print_indent(); print( "addr({})\n", value.ref().visit( - [](const Wasm::Reference::Null&) { return String("null"); }, - [](const auto& ref) { return String::number(ref.address.value()); })); + [](Wasm::Reference::Null const&) { return String("null"); }, + [](auto const& ref) { return String::number(ref.address.value()); })); } } diff --git a/Userland/Libraries/LibWasm/Printer/Printer.h b/Userland/Libraries/LibWasm/Printer/Printer.h index 76cf8f9f34..0fae07ff8c 100644 --- a/Userland/Libraries/LibWasm/Printer/Printer.h +++ b/Userland/Libraries/LibWasm/Printer/Printer.h @@ -12,7 +12,7 @@ namespace Wasm { class Value; -String instruction_name(const OpCode& opcode); +String instruction_name(OpCode const& opcode); struct Printer { explicit Printer(OutputStream& stream, size_t initial_indent = 0) @@ -21,43 +21,43 @@ struct Printer { { } - void print(const Wasm::BlockType&); - void print(const Wasm::CodeSection&); - void print(const Wasm::CodeSection::Code&); - void print(const Wasm::CodeSection::Func&); - void print(const Wasm::CustomSection&); - void print(const Wasm::DataCountSection&); - void print(const Wasm::DataSection&); - void print(const Wasm::DataSection::Data&); - void print(const Wasm::ElementSection&); - void print(const Wasm::ElementSection::Element&); - void print(const Wasm::ExportSection&); - void print(const Wasm::ExportSection::Export&); - void print(const Wasm::Expression&); - void print(const Wasm::FunctionSection&); - void print(const Wasm::FunctionType&); - void print(const Wasm::GlobalSection&); - void print(const Wasm::GlobalSection::Global&); - void print(const Wasm::GlobalType&); - void print(const Wasm::ImportSection&); - void print(const Wasm::ImportSection::Import&); - void print(const Wasm::Instruction&); - void print(const Wasm::Limits&); - void print(const Wasm::Locals&); - void print(const Wasm::MemorySection&); - void print(const Wasm::MemorySection::Memory&); - void print(const Wasm::MemoryType&); - void print(const Wasm::Module&); - void print(const Wasm::Module::Function&); - void print(const Wasm::Reference&); - void print(const Wasm::StartSection&); - void print(const Wasm::StartSection::StartFunction&); - void print(const Wasm::TableSection&); - void print(const Wasm::TableSection::Table&); - void print(const Wasm::TableType&); - void print(const Wasm::TypeSection&); - void print(const Wasm::ValueType&); - void print(const Wasm::Value&); + void print(Wasm::BlockType const&); + void print(Wasm::CodeSection const&); + void print(Wasm::CodeSection::Code const&); + void print(Wasm::CodeSection::Func const&); + void print(Wasm::CustomSection const&); + void print(Wasm::DataCountSection const&); + void print(Wasm::DataSection const&); + void print(Wasm::DataSection::Data const&); + void print(Wasm::ElementSection const&); + void print(Wasm::ElementSection::Element const&); + void print(Wasm::ExportSection const&); + void print(Wasm::ExportSection::Export const&); + void print(Wasm::Expression const&); + void print(Wasm::FunctionSection const&); + void print(Wasm::FunctionType const&); + void print(Wasm::GlobalSection const&); + void print(Wasm::GlobalSection::Global const&); + void print(Wasm::GlobalType const&); + void print(Wasm::ImportSection const&); + void print(Wasm::ImportSection::Import const&); + void print(Wasm::Instruction const&); + void print(Wasm::Limits const&); + void print(Wasm::Locals const&); + void print(Wasm::MemorySection const&); + void print(Wasm::MemorySection::Memory const&); + void print(Wasm::MemoryType const&); + void print(Wasm::Module const&); + void print(Wasm::Module::Function const&); + void print(Wasm::Reference const&); + void print(Wasm::StartSection const&); + void print(Wasm::StartSection::StartFunction const&); + void print(Wasm::TableSection const&); + void print(Wasm::TableSection::Table const&); + void print(Wasm::TableType const&); + void print(Wasm::TypeSection const&); + void print(Wasm::ValueType const&); + void print(Wasm::Value const&); private: void print_indent(); diff --git a/Userland/Libraries/LibWasm/Types.h b/Userland/Libraries/LibWasm/Types.h index c1be47757f..3e9cc5f92d 100644 --- a/Userland/Libraries/LibWasm/Types.h +++ b/Userland/Libraries/LibWasm/Types.h @@ -56,7 +56,7 @@ TYPEDEF_DISTINCT_ORDERED_ID(size_t, LabelIndex); TYPEDEF_DISTINCT_ORDERED_ID(size_t, DataIndex); TYPEDEF_DISTINCT_NUMERIC_GENERAL(u64, true, true, false, true, false, true, InstructionPointer); -ParseError with_eof_check(const InputStream& stream, ParseError error_if_not_eof); +ParseError with_eof_check(InputStream const& stream, ParseError error_if_not_eof); template<typename T> struct GenericIndexParser { @@ -220,7 +220,7 @@ public: { } - const auto& types() const { return m_types; } + auto const& types() const { return m_types; } static ParseResult<ResultType> parse(InputStream& stream); @@ -999,8 +999,8 @@ public: auto& functions() const { return m_functions; } auto& type(TypeIndex index) const { - const FunctionType* type = nullptr; - for_each_section_of_type<TypeSection>([&](const TypeSection& section) { + FunctionType const* type = nullptr; + for_each_section_of_type<TypeSection>([&](TypeSection const& section) { type = §ion.types().at(index.value()); }); |