LLVMFuzzerTestOneInput: 26| 981|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 27| 981| wabt::Errors errors; 28| 981| wabt::Features features; 29| 981| wabt::interp::ModuleDesc module; 30| 981| FuzzedDataProvider data_provider(data, size); 31| | 32| 981|#define WABT_FEATURE(variable, flag, default_, help) \ 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } 34| 981|#include "wabt/feature.def" ------------------ | | 1| |/* | | 2| | * Copyright 2017 WebAssembly Community Group participants | | 3| | * | | 4| | * Licensed under the Apache License, Version 2.0 (the "License"); | | 5| | * you may not use this file except in compliance with the License. | | 6| | * You may obtain a copy of the License at | | 7| | * | | 8| | * http://www.apache.org/licenses/LICENSE-2.0 | | 9| | * | | 10| | * Unless required by applicable law or agreed to in writing, software | | 11| | * distributed under the License is distributed on an "AS IS" BASIS, | | 12| | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | | 13| | * See the License for the specific language governing permissions and | | 14| | * limitations under the License. | | 15| | */ | | 16| | | | 17| |#ifndef WABT_FEATURE | | 18| |#error "You must define WABT_FEATURE before including this file." | | 19| |#endif | | 20| | | | 21| |/* | | 22| | * variable flag default help | | 23| | * ========================================================================= */ | | 24| | | | 25| 981|WABT_FEATURE(exceptions, "exceptions", false, "Experimental exception handling") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 460, False: 521] | | | | ------------------ | | ------------------ | | 26| 981|WABT_FEATURE(mutable_globals, "mutable-globals", true, "Import/export mutable globals") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 475, False: 506] | | | | ------------------ | | ------------------ | | 27| 981|WABT_FEATURE(sat_float_to_int, "saturating-float-to-int", true, "Saturating float-to-int operators") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 403, False: 578] | | | | ------------------ | | ------------------ | | 28| 981|WABT_FEATURE(sign_extension, "sign-extension", true, "Sign-extension operators") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 449, False: 532] | | | | ------------------ | | ------------------ | | 29| 981|WABT_FEATURE(simd, "simd", true, "SIMD support") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 406, False: 575] | | | | ------------------ | | ------------------ | | 30| 981|WABT_FEATURE(threads, "threads", false, "Threading support") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 436, False: 545] | | | | ------------------ | | ------------------ | | 31| 981|WABT_FEATURE(function_references, "function-references", false, "Typed function references") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 405, False: 576] | | | | ------------------ | | ------------------ | | 32| 981|WABT_FEATURE(multi_value, "multi-value", true, "Multi-value") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 422, False: 559] | | | | ------------------ | | ------------------ | | 33| 981|WABT_FEATURE(tail_call, "tail-call", false, "Tail-call support") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 439, False: 542] | | | | ------------------ | | ------------------ | | 34| 981|WABT_FEATURE(bulk_memory, "bulk-memory", true, "Bulk-memory operations") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 438, False: 543] | | | | ------------------ | | ------------------ | | 35| 981|WABT_FEATURE(reference_types, "reference-types", true, "Reference types (externref)") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 437, False: 544] | | | | ------------------ | | ------------------ | | 36| 981|WABT_FEATURE(annotations, "annotations", false, "Custom annotation syntax") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 454, False: 527] | | | | ------------------ | | ------------------ | | 37| 981|WABT_FEATURE(code_metadata, "code-metadata", false, "Code metadata") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 470, False: 511] | | | | ------------------ | | ------------------ | | 38| 981|WABT_FEATURE(gc, "gc", false, "Garbage collection") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 411, False: 570] | | | | ------------------ | | ------------------ | | 39| 981|WABT_FEATURE(memory64, "memory64", false, "64-bit memory") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 422, False: 559] | | | | ------------------ | | ------------------ | | 40| 981|WABT_FEATURE(multi_memory, "multi-memory", false, "Multi-memory") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 397, False: 584] | | | | ------------------ | | ------------------ | | 41| 981|WABT_FEATURE(extended_const, "extended-const", false, "Extended constant expressions") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 387, False: 594] | | | | ------------------ | | ------------------ | | 42| 981|WABT_FEATURE(relaxed_simd, "relaxed-simd", false, "Relaxed SIMD") | | ------------------ | | | | 33| 981| if (data_provider.ConsumeBool()) { features.enable_##variable(); } | | | | ------------------ | | | | | Branch (33:7): [True: 407, False: 574] | | | | ------------------ | | ------------------ ------------------ 35| 981|#undef WABT_FEATURE 36| | // Add only feature related options, but no logging, stop_on_first_error, etc. 37| 981| wabt::ReadBinaryOptions options(features, nullptr, false, false, false); 38| 981| std::vector text = data_provider.ConsumeRemainingBytes(); 39| 981| ReadBinaryInterp("", text.data(), text.size(), options, &errors, 40| 981| &module); 41| 981| return 0; 42| 981|} _ZN4wabt15BinaryReaderNop11BeginModuleEj: 29| 956| Result BeginModule(uint32_t version) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop12BeginSectionEjNS_13BinarySectionEm: 34| 1.99M| Offset size) override { 35| 1.99M| return Result::Ok; 36| 1.99M| } _ZN4wabt15BinaryReaderNop18BeginCustomSectionEjmNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE: 41| 106k| std::string_view section_name) override { 42| 106k| return Result::Ok; 43| 106k| } _ZN4wabt15BinaryReaderNop16EndCustomSectionEv: 44| 46.8k| Result EndCustomSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop16BeginTypeSectionEm: 47| 530| Result BeginTypeSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop12OnStructTypeEjjPNS_7TypeMutE: 58| 4| TypeMut* fields) override { 59| 4| return Result::Ok; 60| 4| } _ZN4wabt15BinaryReaderNop14EndTypeSectionEv: 62| 372| Result EndTypeSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop18BeginImportSectionEm: 65| 59| Result BeginImportSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop13OnImportCountEj: 66| 43| Result OnImportCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop8OnImportEjNS_12ExternalKindENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_: 70| 1.57k| std::string_view field_name) override { 71| 1.57k| return Result::Ok; 72| 1.57k| } _ZN4wabt15BinaryReaderNop16EndImportSectionEv: 110| 12| Result EndImportSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop20BeginFunctionSectionEm: 113| 470| Result BeginFunctionSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop18EndFunctionSectionEv: 118| 374| Result EndFunctionSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop17BeginTableSectionEm: 121| 175| Result BeginTableSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop15EndTableSectionEv: 128| 134| Result EndTableSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop18BeginMemorySectionEm: 131| 277| Result BeginMemorySection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop16EndMemorySectionEv: 136| 256| Result EndMemorySection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop18BeginGlobalSectionEm: 139| 84| Result BeginGlobalSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop9EndGlobalEj: 146| 189| Result EndGlobal(Index index) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop16EndGlobalSectionEv: 147| 30| Result EndGlobalSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop18BeginExportSectionEm: 150| 355| Result BeginExportSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop13OnExportCountEj: 151| 350| Result OnExportCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop16EndExportSectionEv: 158| 127| Result EndExportSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop17BeginStartSectionEm: 161| 18| Result BeginStartSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop16BeginCodeSectionEm: 166| 387| Result BeginCodeSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop19OnFunctionBodyCountEj: 167| 380| Result OnFunctionBodyCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop12OnOpcodeBareEv: 179| 333k| Result OnOpcodeBare() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop14OnOpcodeUint32Ej: 184| 24.7k| Result OnOpcodeUint32(uint32_t value) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop13OnOpcodeIndexEj: 180| 4.09k| Result OnOpcodeIndex(Index value) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop20OnOpcodeUint32Uint32Ejj: 185| 5.83k| Result OnOpcodeUint32Uint32(uint32_t value, uint32_t value2) override { 186| 5.83k| return Result::Ok; 187| 5.83k| } _ZN4wabt15BinaryReaderNop26OnOpcodeUint32Uint32Uint32Ejjj: 190| 361| uint32_t value3) override { 191| 361| return Result::Ok; 192| 361| } _ZN4wabt15BinaryReaderNop14OnOpcodeUint64Em: 199| 1.59k| Result OnOpcodeUint64(uint64_t value) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop11OnOpcodeF32Ej: 200| 2.11k| Result OnOpcodeF32(uint32_t value) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop11OnOpcodeF64Em: 201| 136| Result OnOpcodeF64(uint64_t value) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop12OnOpcodeV128E4v128: 202| 22| Result OnOpcodeV128(v128 value) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop16OnOpcodeBlockSigENS_4TypeE: 203| 2.98k| Result OnOpcodeBlockSig(Type sig_type) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop12OnOpcodeTypeENS_4TypeE: 204| 77| Result OnOpcodeType(Type type) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop13OnCallRefExprEv: 249| 107| Result OnCallRefExpr() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop14EndCodeSectionEv: 323| 1| Result EndCodeSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop16BeginElemSectionEm: 358| 43| Result BeginElemSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop14EndElemSegmentEj: 379| 11| Result EndElemSegment(Index index) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop14EndElemSectionEv: 380| 17| Result EndElemSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop16BeginDataSectionEm: 383| 20| Result BeginDataSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop18OnDataSegmentCountEj: 384| 15| Result OnDataSegmentCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop14EndDataSegmentEj: 397| 16| Result EndDataSegment(Index index) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop14EndDataSectionEv: 398| 5| Result EndDataSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop21BeginDataCountSectionEm: 401| 2| Result BeginDataCountSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop19EndDataCountSectionEv: 403| 2| Result EndDataCountSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop17BeginRelocSectionEm: 457| 8.43k| Result BeginRelocSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop12OnRelocCountEjj: 458| 7.68k| Result OnRelocCount(Index count, Index section_code) override { 459| 7.68k| return Result::Ok; 460| 7.68k| } _ZN4wabt15BinaryReaderNop7OnRelocENS_9RelocTypeEmjj: 464| 19.1k| uint32_t addend) override { 465| 19.1k| return Result::Ok; 466| 19.1k| } _ZN4wabt15BinaryReaderNop15EndRelocSectionEv: 467| 1.27k| Result EndRelocSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop18BeginDylinkSectionEm: 491| 25.6k| Result BeginDylinkSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop12OnDylinkInfoEjjjj: 495| 11.9k| uint32_t table_align) override { 496| 11.9k| return Result::Ok; 497| 11.9k| } _ZN4wabt15BinaryReaderNop19OnDylinkImportCountEj: 502| 972| Result OnDylinkImportCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop19OnDylinkExportCountEj: 503| 406| Result OnDylinkExportCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop14OnDylinkImportENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_j: 506| 160| uint32_t flags) override { 507| 160| return Result::Ok; 508| 160| } _ZN4wabt15BinaryReaderNop14OnDylinkExportENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj: 509| 160| Result OnDylinkExport(std::string_view name, uint32_t flags) override { 510| 160| return Result::Ok; 511| 160| } _ZN4wabt15BinaryReaderNop19OnDylinkNeededCountEj: 498| 1.40k| Result OnDylinkNeededCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop14OnDylinkNeededENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE: 499| 451| Result OnDylinkNeeded(std::string_view so_name) override { 500| 451| return Result::Ok; 501| 451| } _ZN4wabt15BinaryReaderNop16EndDylinkSectionEv: 512| 1.15k| Result EndDylinkSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop26BeginTargetFeaturesSectionEm: 515| 2.85k| Result BeginTargetFeaturesSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop14OnFeatureCountEj: 516| 2.85k| Result OnFeatureCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop9OnFeatureEhNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE: 517| 5.26k| Result OnFeature(uint8_t prefix, std::string_view name) override { 518| 5.26k| return Result::Ok; 519| 5.26k| } _ZN4wabt15BinaryReaderNop24EndTargetFeaturesSectionEv: 520| 576| Result EndTargetFeaturesSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop25BeginGenericCustomSectionEm: 523| 106k| Result BeginGenericCustomSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop22OnGenericCustomSectionENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPKvm: 526| 106k| Offset size) override { 527| 106k| return Result::Ok; 528| 106k| }; _ZN4wabt15BinaryReaderNop23EndGenericCustomSectionEv: 529| 106k| Result EndGenericCustomSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop19BeginLinkingSectionEm: 532| 22.6k| Result BeginLinkingSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop13OnSymbolCountEj: 533| 2.45k| Result OnSymbolCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop12OnDataSymbolEjjNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEjjj: 539| 787| uint32_t size) override { 540| 787| return Result::Ok; 541| 787| } _ZN4wabt15BinaryReaderNop16OnFunctionSymbolEjjNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj: 545| 627| Index func_index) override { 546| 627| return Result::Ok; 547| 627| } _ZN4wabt15BinaryReaderNop14OnGlobalSymbolEjjNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj: 551| 317| Index global_index) override { 552| 317| return Result::Ok; 553| 317| } _ZN4wabt15BinaryReaderNop15OnSectionSymbolEjjj: 556| 27| Index section_index) override { 557| 27| return Result::Ok; 558| 27| } _ZN4wabt15BinaryReaderNop11OnTagSymbolEjjNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj: 562| 237| Index tag_index) override { 563| 237| return Result::Ok; 564| 237| } _ZN4wabt15BinaryReaderNop13OnTableSymbolEjjNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj: 568| 302| Index table_index) override { 569| 302| return Result::Ok; 570| 302| } _ZN4wabt15BinaryReaderNop18OnSegmentInfoCountEj: 571| 1.22k| Result OnSegmentInfoCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop13OnSegmentInfoEjNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEmj: 575| 358| uint32_t flags) override { 576| 358| return Result::Ok; 577| 358| } _ZN4wabt15BinaryReaderNop19OnInitFunctionCountEj: 578| 659| Result OnInitFunctionCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop14OnInitFunctionEjj: 579| 678| Result OnInitFunction(uint32_t priority, Index symbol_index) override { 580| 678| return Result::Ok; 581| 678| } _ZN4wabt15BinaryReaderNop13OnComdatCountEj: 582| 12.1k| Result OnComdatCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop13OnComdatBeginENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEjj: 585| 76.6k| Index count) override { 586| 76.6k| return Result::Ok; 587| 76.6k| } _ZN4wabt15BinaryReaderNop13OnComdatEntryENS_10ComdatTypeEj: 588| 63.8k| Result OnComdatEntry(ComdatType kind, Index index) override { 589| 63.8k| return Result::Ok; 590| 63.8k| } _ZN4wabt15BinaryReaderNop17EndLinkingSectionEv: 591| 477| Result EndLinkingSection() override { return Result::Ok; } _ZN4wabt15BinaryReaderNop15BeginTagSectionEm: 470| 9| Result BeginTagSection(Offset size) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop24BeginCodeMetadataSectionENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEm: 476| 3.49k| Result BeginCodeMetadataSection(std::string_view name, Offset size) override { 477| 3.49k| return Result::Ok; 478| 3.49k| } _ZN4wabt15BinaryReaderNop23OnCodeMetadataFuncCountEj: 479| 3.09k| Result OnCodeMetadataFuncCount(Index count) override { return Result::Ok; } _ZN4wabt15BinaryReaderNop19OnCodeMetadataCountEjj: 480| 3.52k| Result OnCodeMetadataCount(Index function_index, Index count) override { 481| 3.52k| return Result::Ok; 482| 3.52k| } _ZN4wabt15BinaryReaderNop14OnCodeMetadataEmPKvm: 485| 2.09k| Address size) override { 486| 2.09k| return Result::Ok; 487| 2.09k| } _ZN4wabt15BinaryReaderNop22EndCodeMetadataSectionEv: 488| 267| Result EndCodeMetadataSection() override { return Result::Ok; } _ZN4wabt17ReadBinaryOptionsC2ERKNS_8FeaturesEPNS_6StreamEbbb: 45| 981| fail_on_custom_section_error(fail_on_custom_section_error) {} _ZN4wabt20BinaryReaderDelegate5StateC2EPKhm: 66| 981| : data(data), size(size), offset(0) {} _ZN4wabt20BinaryReaderDelegateD2Ev: 73| 1.96k| virtual ~BinaryReaderDelegate() {} _ZN4wabt20BinaryReaderDelegate10OnSetStateEPKNS0_5StateE: 76| 981| virtual void OnSetState(const State* s) { state = s; } _ZN4wabt8LocationC2Ev: 206| 481k| Location() : line(0), first_column(0), last_column(0) {} _ZN4wabt8LocationC2Em: 215| 2.12M| explicit Location(size_t offset) : offset(offset) {} _ZNK4wabt6Limits9IndexTypeEv: 376| 6.96k| Type IndexType() const { return is_64 ? Type::I64 : Type::I32; } ------------------ | Branch (376:35): [True: 13, False: 6.95k] ------------------ binary-reader.cc:_ZN4wabtL16GetRelocTypeNameENS_9RelocTypeE: 405| 876|static inline const char* GetRelocTypeName(RelocType reloc) { 406| 876| return static_cast(reloc) < kRelocTypeCount ------------------ | Branch (406:10): [True: 0, False: 876] ------------------ 407| 876| ? g_reloc_type_name[static_cast(reloc)] 408| 876| : ""; 409| 876|} _ZN4wabt6LimitsC2Ev: 364| 7.36k| Limits() = default; _ZN4wabt10ZeroMemoryI4v128EEvRT_: 168| 22|void ZeroMemory(T& v) { 169| 22| WABT_STATIC_ASSERT(std::is_trivial::value); ------------------ | | 89| 22|#define WABT_STATIC_ASSERT(x) static_assert((x), #x) ------------------ 170| 22| memset(&v, 0, sizeof(v)); 171| 22|} _ZN4wabt5ErrorC2ENS_10ErrorLevelENS_8LocationENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE: 47| 2.12M| : error_level(error_level), loc(loc), message(message) {} _ZN4wabt8Features17enable_exceptionsEv: 38| 460| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features22set_exceptions_enabledEb: 40| 460| void set_##variable##_enabled(bool value) { \ 41| 460| variable##_enabled_ = value; \ 42| 460| UpdateDependencies(); \ 43| 460| } _ZN4wabt8Features22enable_mutable_globalsEv: 38| 475| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features27set_mutable_globals_enabledEb: 40| 475| void set_##variable##_enabled(bool value) { \ 41| 475| variable##_enabled_ = value; \ 42| 475| UpdateDependencies(); \ 43| 475| } _ZN4wabt8Features23enable_sat_float_to_intEv: 38| 403| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features28set_sat_float_to_int_enabledEb: 40| 403| void set_##variable##_enabled(bool value) { \ 41| 403| variable##_enabled_ = value; \ 42| 403| UpdateDependencies(); \ 43| 403| } _ZN4wabt8Features21enable_sign_extensionEv: 38| 449| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features26set_sign_extension_enabledEb: 40| 449| void set_##variable##_enabled(bool value) { \ 41| 449| variable##_enabled_ = value; \ 42| 449| UpdateDependencies(); \ 43| 449| } _ZN4wabt8Features11enable_simdEv: 38| 406| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features16set_simd_enabledEb: 40| 406| void set_##variable##_enabled(bool value) { \ 41| 406| variable##_enabled_ = value; \ 42| 406| UpdateDependencies(); \ 43| 406| } _ZN4wabt8Features14enable_threadsEv: 38| 436| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features19set_threads_enabledEb: 40| 436| void set_##variable##_enabled(bool value) { \ 41| 436| variable##_enabled_ = value; \ 42| 436| UpdateDependencies(); \ 43| 436| } _ZN4wabt8Features26enable_function_referencesEv: 38| 405| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features31set_function_references_enabledEb: 40| 405| void set_##variable##_enabled(bool value) { \ 41| 405| variable##_enabled_ = value; \ 42| 405| UpdateDependencies(); \ 43| 405| } _ZN4wabt8Features18enable_multi_valueEv: 38| 422| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features23set_multi_value_enabledEb: 40| 422| void set_##variable##_enabled(bool value) { \ 41| 422| variable##_enabled_ = value; \ 42| 422| UpdateDependencies(); \ 43| 422| } _ZN4wabt8Features16enable_tail_callEv: 38| 439| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features21set_tail_call_enabledEb: 40| 439| void set_##variable##_enabled(bool value) { \ 41| 439| variable##_enabled_ = value; \ 42| 439| UpdateDependencies(); \ 43| 439| } _ZN4wabt8Features18enable_bulk_memoryEv: 38| 438| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features23set_bulk_memory_enabledEb: 40| 438| void set_##variable##_enabled(bool value) { \ 41| 438| variable##_enabled_ = value; \ 42| 438| UpdateDependencies(); \ 43| 438| } _ZN4wabt8Features22enable_reference_typesEv: 38| 437| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features27set_reference_types_enabledEb: 40| 437| void set_##variable##_enabled(bool value) { \ 41| 437| variable##_enabled_ = value; \ 42| 437| UpdateDependencies(); \ 43| 437| } _ZN4wabt8Features18enable_annotationsEv: 38| 454| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features23set_annotations_enabledEb: 40| 454| void set_##variable##_enabled(bool value) { \ 41| 454| variable##_enabled_ = value; \ 42| 454| UpdateDependencies(); \ 43| 454| } _ZN4wabt8Features20enable_code_metadataEv: 38| 470| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features25set_code_metadata_enabledEb: 40| 470| void set_##variable##_enabled(bool value) { \ 41| 470| variable##_enabled_ = value; \ 42| 470| UpdateDependencies(); \ 43| 470| } _ZN4wabt8Features9enable_gcEv: 38| 411| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features14set_gc_enabledEb: 40| 411| void set_##variable##_enabled(bool value) { \ 41| 411| variable##_enabled_ = value; \ 42| 411| UpdateDependencies(); \ 43| 411| } _ZN4wabt8Features15enable_memory64Ev: 38| 422| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features20set_memory64_enabledEb: 40| 422| void set_##variable##_enabled(bool value) { \ 41| 422| variable##_enabled_ = value; \ 42| 422| UpdateDependencies(); \ 43| 422| } _ZN4wabt8Features19enable_multi_memoryEv: 38| 397| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features24set_multi_memory_enabledEb: 40| 397| void set_##variable##_enabled(bool value) { \ 41| 397| variable##_enabled_ = value; \ 42| 397| UpdateDependencies(); \ 43| 397| } _ZN4wabt8Features21enable_extended_constEv: 38| 387| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features26set_extended_const_enabledEb: 40| 387| void set_##variable##_enabled(bool value) { \ 41| 387| variable##_enabled_ = value; \ 42| 387| UpdateDependencies(); \ 43| 387| } _ZN4wabt8Features19enable_relaxed_simdEv: 38| 407| void enable_##variable() { set_##variable##_enabled(true); } \ _ZN4wabt8Features24set_relaxed_simd_enabledEb: 40| 407| void set_##variable##_enabled(bool value) { \ 41| 407| variable##_enabled_ = value; \ 42| 407| UpdateDependencies(); \ 43| 407| } _ZNK4wabt8Features18exceptions_enabledEv: 37| 39| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features24sat_float_to_int_enabledEv: 37| 2.40k| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features22sign_extension_enabledEv: 37| 5.08k| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features12simd_enabledEv: 37| 18.1k| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features15threads_enabledEv: 37| 255| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features27function_references_enabledEv: 37| 200| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features19multi_value_enabledEv: 37| 3.61k| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features17tail_call_enabledEv: 37| 118| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features19bulk_memory_enabledEv: 37| 375| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features23reference_types_enabledEv: 37| 946| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features21code_metadata_enabledEv: 37| 46.6k| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features10gc_enabledEv: 37| 1.56k| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features16memory64_enabledEv: 37| 6.12k| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features20multi_memory_enabledEv: 37| 912| bool variable##_enabled() const { return variable##_enabled_; } \ _ZNK4wabt8Features22extended_const_enabledEv: 37| 61| bool variable##_enabled() const { return variable##_enabled_; } \ _ZN4wabt6interp8FuncTypeC2ENSt3__16vectorINS_4TypeENS2_9allocatorIS4_EEEES7_: 45| 1.80k| : ExternType(ExternKind::Func), params(params), results(results) {} _ZN4wabt6interp10ExternTypeC2ENS_12ExternalKindE: 36| 2.53k|inline ExternType::ExternType(ExternKind kind) : kind(kind) {} _ZN4wabt6interp10ImportTypeC2ERKS1_: 100| 4.15k| : module(other.module), name(other.name), type(other.type->Clone()) {} _ZN4wabt6interp10ImportTypeC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES8_NS2_10unique_ptrINS0_10ExternTypeENS2_14default_deleteISA_EEEE: 97| 1.55k| : module(module), name(name), type(std::move(type)) {} _ZN4wabt6interp9TableTypeC2ENS_4TypeENS_6LimitsE: 54| 146| : ExternType(ExternKind::Table), element(element), limits(limits) { 55| | // Always set max. 56| 146| if (!limits.has_max) { ------------------ | Branch (56:7): [True: 94, False: 52] ------------------ 57| 94| this->limits.max = std::numeric_limits::max(); 58| 94| } 59| 146|} _ZN4wabt6interp10MemoryTypeC2ENS_6LimitsE: 68| 340| : ExternType(ExternKind::Memory), limits(limits) { 69| | // Always set max. 70| 340| if (!limits.has_max) { ------------------ | Branch (70:7): [True: 184, False: 156] ------------------ 71| 184| this->limits.max = limits.is_64 ? WABT_MAX_PAGES64 : WABT_MAX_PAGES32; ------------------ | | 51| 15|#define WABT_MAX_PAGES64 0x1000000000000 ------------------ this->limits.max = limits.is_64 ? WABT_MAX_PAGES64 : WABT_MAX_PAGES32; ------------------ | | 49| 353|#define WABT_MAX_PAGES32 0x10000 ------------------ | Branch (71:24): [True: 15, False: 169] ------------------ 72| 184| } 73| 340|} _ZN4wabt6interp10GlobalTypeC2ENS_4TypeENS0_10MutabilityE: 82| 242| : ExternType(ExternKind::Global), type(type), mut(mut) {} _ZN4wabt6interp7TagTypeC2ENS0_7TagAttrERKNSt3__16vectorINS_4TypeENS3_9allocatorIS5_EEEE: 91| 3| : ExternType(ExternKind::Tag), attr(attr), signature(signature) {} _ZN4wabt6interp10ExportTypeC2ERKS1_: 117| 4.57k| : name(other.name), type(other.type->Clone()) {} _ZN4wabt6interp10ExportTypeC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_10unique_ptrINS0_10ExternTypeENS2_14default_deleteISA_EEEE: 114| 2.00k| : name(name), type(std::move(type)) {} _ZN4wabt6interp3RefC2Em: 25| 2|inline Ref::Ref(size_t index) : index(index) {} _ZN4wabt6interp10ExternTypeD2Ev: 167| 55.9k| virtual ~ExternType() {} _ZNK4wabt3Var8is_indexEv: 54| 104k| bool is_index() const { return type_ == VarType::Index; } _ZNK4wabt3Var7is_nameEv: 55| 137k| bool is_name() const { return type_ == VarType::Name; } _ZNK4wabt3Var5indexEv: 57| 50.1k| Index index() const { 58| 50.1k| assert(is_index()); 59| 50.1k| return index_; 60| 50.1k| } _ZN4wabt6OpcodeC2ENS0_4EnumE: 52| 620k| Opcode(Enum e) : enum_(e) {} _ZNK4wabt6OpcodecvNS0_4EnumEEv: 53| 498k| operator Enum() const { return enum_; } _ZNK4wabt6Opcode9HasPrefixEv: 57| 100| bool HasPrefix() const { return GetInfo().prefix != 0; } _ZNK4wabt6Opcode9GetPrefixEv: 58| 20| uint8_t GetPrefix() const { return GetInfo().prefix; } _ZNK4wabt6Opcode7GetCodeEv: 59| 100| uint32_t GetCode() const { return GetInfo().code; } _ZNK4wabt6Opcode7GetNameEv: 61| 116k| const char* GetName() const { return GetInfo().name; } _ZNK4wabt6Opcode13GetResultTypeEv: 65| 116k| Type GetResultType() const { return GetInfo().result_type; } _ZNK4wabt6Opcode13GetParamType1Ev: 66| 116k| Type GetParamType1() const { return GetInfo().param_types[0]; } _ZNK4wabt6Opcode13GetParamType2Ev: 67| 57.4k| Type GetParamType2() const { return GetInfo().param_types[1]; } _ZNK4wabt6Opcode13GetParamType3Ev: 68| 350| Type GetParamType3() const { return GetInfo().param_types[2]; } _ZNK4wabt6Opcode13GetMemorySizeEv: 70| 5.74k| Address GetMemorySize() const { return GetInfo().memory_size; } _ZN4wabt6Opcode12IsPrefixByteEh: 86| 379k| static bool IsPrefixByte(uint8_t byte) { 87| 379k| return byte == kMathPrefix || byte == kThreadsPrefix || byte == kSimdPrefix; ------------------ | Branch (87:12): [True: 2.82k, False: 376k] | Branch (87:35): [True: 253, False: 376k] | Branch (87:61): [True: 45.4k, False: 331k] ------------------ 88| 379k| } _ZN4wabt6Opcode10PrefixCodeEhj: 109| 380k| static uint32_t PrefixCode(uint8_t prefix, uint32_t code) { 110| 380k| if (code >= (1 << MAX_OPCODE_BITS)) { ------------------ | | 32| 380k|#define MAX_OPCODE_BITS 9 ------------------ | Branch (110:9): [True: 15, False: 380k] ------------------ 111| | // Clamp to (2^bits - 1), since we know that it is an invalid code. 112| 15| code = (1 << MAX_OPCODE_BITS) - 1; ------------------ | | 32| 15|#define MAX_OPCODE_BITS 9 ------------------ 113| 15| } 114| 380k| return (prefix << MAX_OPCODE_BITS) | code; ------------------ | | 32| 380k|#define MAX_OPCODE_BITS 9 ------------------ 115| 380k| } _ZN4wabt6Opcode19EncodeInvalidOpcodeEj: 129| 81| static Enum EncodeInvalidOpcode(uint32_t prefix_code) { 130| 81| Enum result = static_cast(~prefix_code + 1); 131| 81| assert(result >= Invalid); 132| 81| return result; 133| 81| } _ZN4wabt6Opcode19DecodeInvalidOpcodeENS0_4EnumEPhPj: 137| 182| uint32_t* out_code) { 138| 182| uint32_t prefix_code = ~static_cast(e) + 1; 139| 182| *out_prefix = prefix_code >> MAX_OPCODE_BITS; ------------------ | | 32| 182|#define MAX_OPCODE_BITS 9 ------------------ 140| 182| *out_code = prefix_code & 0xff; 141| 182| } _ZN4wabt6Opcode8FromCodeEj: 150| 331k|inline Opcode Opcode::FromCode(uint32_t code) { 151| 331k| return FromCode(0, code); 152| 331k|} _ZN4wabt6Opcode8FromCodeEhj: 155| 379k|inline Opcode Opcode::FromCode(uint8_t prefix, uint32_t code) { 156| 379k| uint32_t prefix_code = PrefixCode(prefix, code); 157| | 158| 379k| if (WABT_LIKELY(prefix_code < WABT_ARRAY_SIZE(WabtOpcodeCodeTable))) { ------------------ | | 73| 379k|#define WABT_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (73:24): [True: 379k, False: 0] | | ------------------ ------------------ 159| 379k| uint32_t value = WabtOpcodeCodeTable[prefix_code]; 160| | // The default value in the table is 0. That's a valid value, but only if 161| | // the code is 0 (for nop). 162| 379k| if (WABT_LIKELY(value != 0 || code == 0)) { ------------------ | | 73| 567k|#define WABT_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (73:24): [True: 379k, False: 81] | | | Branch (73:44): [True: 191k, False: 188k] | | | Branch (73:44): [True: 188k, False: 81] | | ------------------ ------------------ 163| 379k| return Opcode(static_cast(value)); 164| 379k| } 165| 379k| } 166| | 167| 81| return Opcode(EncodeInvalidOpcode(prefix_code)); 168| 379k|} _ZN4wabt6ResultC2ENS0_4EnumE: 29| 23.7M| Result(Enum e) : enum_(e) {} _ZNK4wabt6ResultcvNS0_4EnumEEv: 30| 24.4M| operator Enum() const { return enum_; } _ZN4wabtorENS_6ResultES0_: 37| 913k|inline Result operator|(Result lhs, Result rhs) { 38| 913k| return (lhs == Result::Error || rhs == Result::Error) ? Result::Error ------------------ | Branch (38:11): [True: 3.34k, False: 909k] | Branch (38:35): [True: 1.11k, False: 908k] ------------------ 39| 913k| : Result::Ok; 40| 913k|} _ZN4wabt6ResultoRES0_: 42| 730k|inline Result& Result::operator|=(Result rhs) { 43| 730k| enum_ = *this | rhs; 44| 730k| return *this; 45| 730k|} _ZN4wabt9SucceededENS_6ResultE: 47| 5.94M|inline bool Succeeded(Result result) { 48| 5.94M| return result == Result::Ok; 49| 5.94M|} _ZN4wabt6FailedENS_6ResultE: 50| 15.9M|inline bool Failed(Result result) { 51| 15.9M| return result == Result::Error; 52| 15.9M|} _ZN4wabt15ValidateOptionsC2ERKNS_8FeaturesE: 38| 981| ValidateOptions(const Features& features) : features(features) {} _ZN4wabt15SharedValidator8GetLabelEjPPNS_11TypeChecker5LabelE: 51| 8.38k| Result GetLabel(Index depth, Label** out_label) { 52| 8.38k| return typechecker_.GetLabel(depth, out_label); 53| 8.38k| } _ZNK4wabt15SharedValidator15type_stack_sizeEv: 50| 18.1k| size_t type_stack_size() const { return typechecker_.type_stack_size(); } _ZN4wabt15SharedValidator13GetCatchCountEjPj: 54| 5.85k| Result GetCatchCount(Index depth, Index* out_count) { 55| 5.85k| return typechecker_.GetCatchCount(depth, out_count); 56| 5.85k| } _ZN4wabt15SharedValidator8FuncTypeC2ERKNSt3__16vectorINS_4TypeENS2_9allocatorIS4_EEEES9_j: 224| 1.47k| : params(params), results(results), type_index(type_index) {} _ZN4wabt15SharedValidator9TableTypeC2ENS_4TypeENS_6LimitsE: 247| 146| TableType(Type element, Limits limits) : element(element), limits(limits) {} _ZN4wabt15SharedValidator10MemoryTypeC2ENS_6LimitsE: 255| 343| MemoryType(Limits limits) : limits(limits) {} _ZN4wabt15SharedValidator10GlobalTypeC2ENS_4TypeEb: 262| 242| GlobalType(Type type, bool mutable_) : type(type), mutable_(mutable_) {} _ZN4wabt15SharedValidator8ElemTypeC2ENS_4TypeEbS2_: 275| 22| : element(element), is_active(is_active), table_type(table_type) {} _ZN4wabt15SharedValidator8FuncTypeC2Ev: 220| 12.4k| FuncType() = default; _ZN4wabt15SharedValidator9TableTypeC2Ev: 246| 686| TableType() = default; _ZN4wabt15SharedValidator10MemoryTypeC2Ev: 254| 6.16k| MemoryType() = default; _ZN4wabt15SharedValidator10GlobalTypeC2Ev: 261| 231| GlobalType() = default; _ZN4wabt12StringPrintfEPKcz: 53| 137| StringPrintf(const char* format, ...) { 54| 137| va_list args; 55| 137| va_list args_copy; 56| 137| va_start(args, format); 57| 137| va_copy(args_copy, args); 58| 137| size_t len = wabt_vsnprintf(nullptr, 0, format, args) + 1; // For \0. ------------------ | | 301| 137|#define wabt_vsnprintf vsnprintf ------------------ 59| 137| std::vector buffer(len); 60| 137| va_end(args); 61| 137| wabt_vsnprintf(buffer.data(), len, format, args_copy); ------------------ | | 301| 137|#define wabt_vsnprintf vsnprintf ------------------ 62| 137| va_end(args_copy); 63| 137| return std::string(buffer.data(), len - 1); 64| 137|} _ZN4wabt11TypeChecker5Label8br_typesEv: 40| 11.6k| TypeVector& br_types() { 41| 11.6k| return label_type == LabelType::Loop ? param_types : result_types; ------------------ | Branch (41:14): [True: 1.58k, False: 10.0k] ------------------ 42| 11.6k| } _ZNK4wabt11TypeChecker15type_stack_sizeEv: 57| 18.1k| size_t type_stack_size() const { return type_stack_.size(); } _ZN4wabt11TypeCheckerC2ERKNS_8FeaturesE: 51| 981| explicit TypeChecker(const Features& features) : features_(features) {} _ZN4wabt11TypeChecker18set_error_callbackERKNSt3__18functionIFvPKcEEE: 53| 981| void set_error_callback(const ErrorCallback& error_callback) { 54| 981| error_callback_ = error_callback; 55| 981| } _ZN4wabt11TypeChecker18PrintStackIfFailedIJNS_4TypeEEEEvNS_6ResultEPKcDpT_: 185| 62.4k| void PrintStackIfFailed(Result result, const char* desc, Args... args) { 186| | // Assert all args are Type or Type::Enum. If it's a TypeVector then 187| | // PrintStackIfFailedV() should be used instead. 188| 62.4k| static_assert((std::is_constructible_v && ...)); 189| | // Minor optimization, check result before constructing the vector to pass 190| | // to the other overload of PrintStackIfFailed. 191| 62.4k| if (Failed(result)) { ------------------ | Branch (191:9): [True: 45, False: 62.4k] ------------------ 192| 45| PrintStackIfFailedV(result, desc, {args...}, /*is_end=*/false); 193| 45| } 194| 62.4k| } _ZN4wabt11TypeChecker18PrintStackIfFailedIJNS_4TypeES2_EEEvNS_6ResultEPKcDpT_: 185| 57.1k| void PrintStackIfFailed(Result result, const char* desc, Args... args) { 186| | // Assert all args are Type or Type::Enum. If it's a TypeVector then 187| | // PrintStackIfFailedV() should be used instead. 188| 57.1k| static_assert((std::is_constructible_v && ...)); 189| | // Minor optimization, check result before constructing the vector to pass 190| | // to the other overload of PrintStackIfFailed. 191| 57.1k| if (Failed(result)) { ------------------ | Branch (191:9): [True: 54, False: 57.1k] ------------------ 192| 54| PrintStackIfFailedV(result, desc, {args...}, /*is_end=*/false); 193| 54| } 194| 57.1k| } _ZN4wabt11TypeChecker18PrintStackIfFailedIJNS_4TypeES2_S2_EEEvNS_6ResultEPKcDpT_: 185| 415| void PrintStackIfFailed(Result result, const char* desc, Args... args) { 186| | // Assert all args are Type or Type::Enum. If it's a TypeVector then 187| | // PrintStackIfFailedV() should be used instead. 188| 415| static_assert((std::is_constructible_v && ...)); 189| | // Minor optimization, check result before constructing the vector to pass 190| | // to the other overload of PrintStackIfFailed. 191| 415| if (Failed(result)) { ------------------ | Branch (191:9): [True: 1, False: 414] ------------------ 192| 1| PrintStackIfFailedV(result, desc, {args...}, /*is_end=*/false); 193| 1| } 194| 415| } _ZN4wabt11TypeChecker18PrintStackIfFailedIJNS_4Type4EnumEEEEvNS_6ResultEPKcDpT_: 185| 94| void PrintStackIfFailed(Result result, const char* desc, Args... args) { 186| | // Assert all args are Type or Type::Enum. If it's a TypeVector then 187| | // PrintStackIfFailedV() should be used instead. 188| 94| static_assert((std::is_constructible_v && ...)); 189| | // Minor optimization, check result before constructing the vector to pass 190| | // to the other overload of PrintStackIfFailed. 191| 94| if (Failed(result)) { ------------------ | Branch (191:9): [True: 0, False: 94] ------------------ 192| 0| PrintStackIfFailedV(result, desc, {args...}, /*is_end=*/false); 193| 0| } 194| 94| } _ZN4wabt11TypeChecker18PrintStackIfFailedIJNS_4TypeES2_NS2_4EnumEEEEvNS_6ResultEPKcDpT_: 185| 966| void PrintStackIfFailed(Result result, const char* desc, Args... args) { 186| | // Assert all args are Type or Type::Enum. If it's a TypeVector then 187| | // PrintStackIfFailedV() should be used instead. 188| 966| static_assert((std::is_constructible_v && ...)); 189| | // Minor optimization, check result before constructing the vector to pass 190| | // to the other overload of PrintStackIfFailed. 191| 966| if (Failed(result)) { ------------------ | Branch (191:9): [True: 2, False: 964] ------------------ 192| 2| PrintStackIfFailedV(result, desc, {args...}, /*is_end=*/false); 193| 2| } 194| 966| } _ZN4wabt4TypeC2Ei: 62| 6.73k| : enum_(static_cast(code)), type_index_(kInvalidIndex) {} _ZN4wabt4TypeC2ENS0_4EnumE: 63| 351k| Type(Enum e) : enum_(e), type_index_(kInvalidIndex) {} _ZN4wabt4TypeC2ENS0_4EnumEj: 64| 11| Type(Enum e, Index type_index) : enum_(e), type_index_(type_index) { 65| 11| assert(e == Enum::Reference); 66| 11| } _ZNK4wabt4TypecvNS0_4EnumEEv: 67| 721k| constexpr operator Enum() const { return enum_; } _ZNK4wabt4Type5IsRefEv: 69| 2.17k| bool IsRef() const { 70| 2.17k| return enum_ == Type::ExternRef || enum_ == Type::FuncRef || ------------------ | Branch (70:12): [True: 100, False: 2.07k] | Branch (70:40): [True: 224, False: 1.84k] ------------------ 71| 2.17k| enum_ == Type::Reference; ------------------ | Branch (71:12): [True: 2, False: 1.84k] ------------------ 72| 2.17k| } _ZNK4wabt4Type7GetNameEv: 81| 300| std::string GetName() const { 82| 300| switch (enum_) { 83| 119| case Type::I32: return "i32"; ------------------ | Branch (83:7): [True: 119, False: 181] ------------------ 84| 44| case Type::I64: return "i64"; ------------------ | Branch (84:7): [True: 44, False: 256] ------------------ 85| 26| case Type::F32: return "f32"; ------------------ | Branch (85:7): [True: 26, False: 274] ------------------ 86| 42| case Type::F64: return "f64"; ------------------ | Branch (86:7): [True: 42, False: 258] ------------------ 87| 61| case Type::V128: return "v128"; ------------------ | Branch (87:7): [True: 61, False: 239] ------------------ 88| 0| case Type::I8: return "i8"; ------------------ | Branch (88:7): [True: 0, False: 300] ------------------ 89| 0| case Type::I16: return "i16"; ------------------ | Branch (89:7): [True: 0, False: 300] ------------------ 90| 3| case Type::FuncRef: return "funcref"; ------------------ | Branch (90:7): [True: 3, False: 297] ------------------ 91| 0| case Type::Func: return "func"; ------------------ | Branch (91:7): [True: 0, False: 300] ------------------ 92| 0| case Type::Void: return "void"; ------------------ | Branch (92:7): [True: 0, False: 300] ------------------ 93| 4| case Type::Any: return "any"; ------------------ | Branch (93:7): [True: 4, False: 296] ------------------ 94| 1| case Type::ExternRef: return "externref"; ------------------ | Branch (94:7): [True: 1, False: 299] ------------------ 95| 0| case Type::Reference: ------------------ | Branch (95:7): [True: 0, False: 300] ------------------ 96| 0| return StringPrintf("(ref %d)", type_index_); 97| 0| default: ------------------ | Branch (97:7): [True: 0, False: 300] ------------------ 98| 0| return StringPrintf("", enum_); 99| 300| } 100| 300| } _ZNK4wabt4Type7IsIndexEv: 124| 8.06k| bool IsIndex() const { return static_cast(enum_) >= 0; } _ZNK4wabt4Type8GetIndexEv: 126| 2.05k| Index GetIndex() const { 127| 2.05k| assert(IsIndex()); 128| 2.05k| return static_cast(enum_); 129| 2.05k| } _ZNK4wabt4Type15GetInlineVectorEv: 136| 954| TypeVector GetInlineVector() const { 137| 954| assert(!IsIndex()); 138| 954| switch (enum_) { 139| 526| case Type::Void: ------------------ | Branch (139:7): [True: 526, False: 428] ------------------ 140| 526| return TypeVector(); 141| | 142| 224| case Type::I32: ------------------ | Branch (142:7): [True: 224, False: 730] ------------------ 143| 224| case Type::I64: ------------------ | Branch (143:7): [True: 0, False: 954] ------------------ 144| 224| case Type::F32: ------------------ | Branch (144:7): [True: 0, False: 954] ------------------ 145| 224| case Type::F64: ------------------ | Branch (145:7): [True: 0, False: 954] ------------------ 146| 334| case Type::V128: ------------------ | Branch (146:7): [True: 110, False: 844] ------------------ 147| 334| case Type::FuncRef: ------------------ | Branch (147:7): [True: 0, False: 954] ------------------ 148| 427| case Type::ExternRef: ------------------ | Branch (148:7): [True: 93, False: 861] ------------------ 149| 428| case Type::Reference: ------------------ | Branch (149:7): [True: 1, False: 953] ------------------ 150| 428| return TypeVector(this, this + 1); 151| | 152| 0| default: ------------------ | Branch (152:7): [True: 0, False: 954] ------------------ 153| 0| WABT_UNREACHABLE; ------------------ | | 112| 0|#define WABT_UNREACHABLE abort() ------------------ 154| 954| } 155| 954| } _ZN4wabt19BinaryReaderLoggingC2EPNS_6StreamEPNS_20BinaryReaderDelegateE: 53| 981| : stream_(stream), reader_(forward), indent_(0) {} _ZN4wabt10ReadBinaryEPKvmPNS_20BinaryReaderDelegateERKNS_17ReadBinaryOptionsE: 3029| 981| const ReadBinaryOptions& options) { 3030| 981| BinaryReader reader(data, size, delegate, options); 3031| 981| return reader.ReadModule( 3032| 981| BinaryReader::ReadModuleOptions{options.stop_on_first_error}); 3033| 981|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReaderC2EPKvmPNS_20BinaryReaderDelegateERKNS_17ReadBinaryOptionsE: 218| 981| last_known_section_(BinarySection::Invalid) { 219| 981| delegate->OnSetState(&state_); 220| 981|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader10ReadModuleERKNS1_17ReadModuleOptionsE: 3003| 981|Result BinaryReader::ReadModule(const ReadModuleOptions& options) { 3004| 981| uint32_t magic = 0; 3005| 981| CHECK_RESULT(ReadU32(&magic, "magic")); ------------------ | | 55| 981| do { \ | | 56| 981| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 981] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 981| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 3006| 981| ERROR_UNLESS(magic == WABT_BINARY_MAGIC, "bad magic value"); ------------------ | | 48| 981|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 981| do { \ | | | | 42| 981| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 23, False: 958] | | | | ------------------ | | | | 43| 23| PrintError(__VA_ARGS__); \ | | | | 44| 23| return Result::Error; \ | | | | 45| 23| } \ | | | | 46| 981| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3007| 958| uint32_t version = 0; 3008| 958| CHECK_RESULT(ReadU32(&version, "version")); ------------------ | | 55| 958| do { \ | | 56| 958| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 958] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 958| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 3009| 958| ERROR_UNLESS(version == WABT_BINARY_VERSION, ------------------ | | 48| 958|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 958| do { \ | | | | 42| 958| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 2, False: 956] | | | | ------------------ | | | | 43| 2| PrintError(__VA_ARGS__); \ | | | | 44| 2| return Result::Error; \ | | | | 45| 2| } \ | | | | 46| 958| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3010| 956| "bad wasm file version: %#x (expected %#x)", version, 3011| 956| WABT_BINARY_VERSION); 3012| | 3013| 956| CALLBACK(BeginModule, version); ------------------ | | 61| 956| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 956|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 956| do { \ | | | | | | 42| 956| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 956] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 956| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 956| #member " callback failed") ------------------ 3014| 956| CHECK_RESULT(ReadSections(ReadSectionsOptions{options.stop_on_first_error})); ------------------ | | 55| 956| do { \ | | 56| 956| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 921, False: 35] | | ------------------ | | 57| 921| return ::wabt::Result::Error; \ | | 58| 921| } \ | | 59| 956| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 3015| | // This is checked in ReadCodeSection, but it must be checked at the end too, 3016| | // in case the code section was omitted. 3017| 35| ERROR_UNLESS(num_function_signatures_ == num_function_bodies_, ------------------ | | 48| 35|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 35| do { \ | | | | 42| 35| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 1, False: 34] | | | | ------------------ | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | 44| 1| return Result::Error; \ | | | | 45| 1| } \ | | | | 46| 35| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3018| 34| "function signature count != function body count"); 3019| 34| CALLBACK0(EndModule); ------------------ | | 58| 34| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 34|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 34| do { \ | | | | | | 42| 34| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 34] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 34| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3020| | 3021| 34| return Result::Ok; 3022| 34|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader7ReadU32EPjPKc: 298| 1.93k|Result BinaryReader::ReadU32(uint32_t* out_value, const char* desc) { 299| 1.93k| return ReadT(out_value, "uint32_t", desc); 300| 1.93k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader5ReadTIjEENS_6ResultEPT_PKcS7_: 277| 4.05k| const char* desc) { 278| 4.05k| if (state_.offset + sizeof(T) > read_end_) { ------------------ | Branch (278:7): [True: 0, False: 4.05k] ------------------ 279| 0| PrintError("unable to read %s: %s", type_name, desc); 280| 0| return Result::Error; 281| 0| } 282| |#if WABT_BIG_ENDIAN 283| | uint8_t tmp[sizeof(T)]; 284| | memcpy(tmp, state_.data + state_.offset, sizeof(tmp)); 285| | SwapBytesSized(tmp, sizeof(tmp)); 286| | memcpy(out_value, tmp, sizeof(T)); 287| |#else 288| 4.05k| memcpy(out_value, state_.data + state_.offset, sizeof(T)); 289| 4.05k|#endif 290| 4.05k| state_.offset += sizeof(T); 291| 4.05k| return Result::Ok; 292| 4.05k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader10PrintErrorEPKcz: 223| 2.12M| ...) { 224| 2.12M| ErrorLevel error_level = 225| 2.12M| reading_custom_section_ && !options_.fail_on_custom_section_error ------------------ | Branch (225:7): [True: 59.3k, False: 2.06M] | Branch (225:34): [True: 59.3k, False: 0] ------------------ 226| 2.12M| ? ErrorLevel::Warning 227| 2.12M| : ErrorLevel::Error; 228| | 229| 2.12M| WABT_SNPRINTF_ALLOCA(buffer, length, format); ------------------ | | 36| 2.12M| va_list args; \ | | 37| 2.12M| va_list args_copy; \ | | 38| 2.12M| va_start(args, format); \ | | 39| 2.12M| va_copy(args_copy, args); \ | | 40| 2.12M| char fixed_buf[WABT_DEFAULT_SNPRINTF_ALLOCA_BUFSIZE]; \ | | 41| 2.12M| char* buffer = fixed_buf; \ | | 42| 2.12M| size_t len = wabt_vsnprintf(fixed_buf, sizeof(fixed_buf), format, args); \ | | ------------------ | | | | 301| 2.12M|#define wabt_vsnprintf vsnprintf | | ------------------ | | 43| 2.12M| va_end(args); \ | | 44| 2.12M| if (len + 1 > sizeof(fixed_buf)) { \ | | ------------------ | | | Branch (44:7): [True: 0, False: 2.12M] | | ------------------ | | 45| 0| buffer = static_cast(alloca(len + 1)); \ | | 46| 0| len = wabt_vsnprintf(buffer, len + 1, format, args_copy); \ | | ------------------ | | | | 301| 0|#define wabt_vsnprintf vsnprintf | | ------------------ | | 47| 0| } \ | | 48| 2.12M| va_end(args_copy) ------------------ 230| 2.12M| Error error(error_level, Location(state_.offset), buffer); 231| 2.12M| bool handled = delegate_->OnError(error); 232| | 233| 2.12M| if (!handled) { ------------------ | Branch (233:7): [True: 0, False: 2.12M] ------------------ 234| | // Not great to just print, but we don't want to eat the error either. 235| 0| fprintf(stderr, "%07" PRIzx ": %s: %s\n", state_.offset, 236| 0| GetErrorLevelName(error_level), buffer); 237| 0| } 238| 2.12M|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader12ReadSectionsERKNS1_19ReadSectionsOptionsE: 2854| 956|Result BinaryReader::ReadSections(const ReadSectionsOptions& options) { 2855| 956| Result result = Result::Ok; 2856| 956| Index section_index = 0; 2857| 956| bool seen_section_code[static_cast(BinarySection::Last) + 1] = {false}; 2858| | 2859| 2.16M| for (; state_.offset < state_.size; ++section_index) { ------------------ | Branch (2859:10): [True: 2.16M, False: 465] ------------------ 2860| 2.16M| uint8_t section_code; 2861| 2.16M| Offset section_size; 2862| 2.16M| CHECK_RESULT(ReadU8(§ion_code, "section code")); ------------------ | | 55| 2.16M| do { \ | | 56| 2.16M| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2.16M] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2.16M| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2863| 2.16M| CHECK_RESULT(ReadOffset(§ion_size, "section size")); ------------------ | | 55| 2.16M| do { \ | | 56| 2.16M| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 142, False: 2.16M] | | ------------------ | | 57| 142| return ::wabt::Result::Error; \ | | 58| 142| } \ | | 59| 2.16M| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2864| 2.16M| ReadEndRestoreGuard guard(this); 2865| 2.16M| read_end_ = state_.offset + section_size; 2866| 2.16M| if (section_code >= kBinarySectionCount) { ------------------ | Branch (2866:9): [True: 168k, False: 1.99M] ------------------ 2867| 168k| PrintError("invalid section code: %u", section_code); 2868| 168k| if (options.stop_on_first_error) { ------------------ | Branch (2868:11): [True: 0, False: 168k] ------------------ 2869| 0| return Result::Error; 2870| 0| } 2871| | // If we don't have to stop on first error, continue reading 2872| | // sections, because although we could not understand the 2873| | // current section, we can continue and correctly parse 2874| | // subsequent sections, so we can give back as much information 2875| | // as we can understand. 2876| 168k| result = Result::Error; 2877| 168k| state_.offset = read_end_; 2878| 168k| continue; 2879| 168k| } 2880| | 2881| 1.99M| BinarySection section = static_cast(section_code); 2882| 1.99M| if (section != BinarySection::Custom) { ------------------ | Branch (2882:9): [True: 2.56k, False: 1.99M] ------------------ 2883| 2.56k| if (seen_section_code[section_code]) { ------------------ | Branch (2883:11): [True: 65, False: 2.49k] ------------------ 2884| 65| PrintError("multiple %s sections", GetSectionName(section)); 2885| 65| return Result::Error; 2886| 65| } 2887| 2.49k| seen_section_code[section_code] = true; 2888| 2.49k| } 2889| | 2890| 1.99M| ERROR_UNLESS(read_end_ <= state_.size, ------------------ | | 48| 1.99M|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 1.99M| do { \ | | | | 42| 1.99M| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 236, False: 1.99M] | | | | ------------------ | | | | 43| 236| PrintError(__VA_ARGS__); \ | | | | 44| 236| return Result::Error; \ | | | | 45| 236| } \ | | | | 46| 1.99M| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2891| 1.99M| "invalid section size: extends past end"); 2892| | 2893| 1.99M| ERROR_UNLESS( ------------------ | | 48| 1.99M|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 1.99M| do { \ | | | | 42| 7.78M| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 207k, False: 1.79M] | | | | | Branch (42:9): [True: 1.78M, False: 1.71k] | | | | | Branch (42:9): [True: 1.66k, False: 47] | | | | ------------------ | | | | 43| 47| PrintError(__VA_ARGS__); \ | | | | 44| 47| return Result::Error; \ | | | | 45| 47| } \ | | | | 46| 1.99M| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2894| 1.99M| last_known_section_ == BinarySection::Invalid || 2895| 1.99M| section == BinarySection::Custom || 2896| 1.99M| GetSectionOrder(section) > GetSectionOrder(last_known_section_), 2897| 1.99M| "section %s out of order", GetSectionName(section)); 2898| | 2899| 1.99M| ERROR_UNLESS(!did_read_names_section_ || section == BinarySection::Custom, ------------------ | | 48| 1.99M|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 1.99M| do { \ | | | | 42| 3.99M| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 1.99M, False: 0] | | | | | Branch (42:9): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 1.99M| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2900| 1.99M| "%s section can not occur after Name section", 2901| 1.99M| GetSectionName(section)); 2902| | 2903| 1.99M| CALLBACK(BeginSection, section_index, section, section_size); ------------------ | | 61| 1.99M| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.99M|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.99M| do { \ | | | | | | 42| 1.99M| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.99M] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.99M| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.99M| #member " callback failed") ------------------ 2904| | 2905| 1.99M| bool stop_on_first_error = options_.stop_on_first_error; 2906| 1.99M| Result section_result = Result::Error; 2907| 1.99M| switch (section) { ------------------ | Branch (2907:13): [True: 0, False: 1.99M] ------------------ 2908| 1.99M| case BinarySection::Custom: ------------------ | Branch (2908:7): [True: 1.99M, False: 2.43k] ------------------ 2909| 1.99M| section_result = ReadCustomSection(section_index, section_size); 2910| 1.99M| if (options_.fail_on_custom_section_error) { ------------------ | Branch (2910:13): [True: 0, False: 1.99M] ------------------ 2911| 0| result |= section_result; 2912| 1.99M| } else { 2913| 1.99M| stop_on_first_error = false; 2914| 1.99M| } 2915| 1.99M| break; 2916| 530| case BinarySection::Type: ------------------ | Branch (2916:7): [True: 530, False: 1.99M] ------------------ 2917| 530| section_result = ReadTypeSection(section_size); 2918| 530| result |= section_result; 2919| 530| break; 2920| 59| case BinarySection::Import: ------------------ | Branch (2920:7): [True: 59, False: 1.99M] ------------------ 2921| 59| section_result = ReadImportSection(section_size); 2922| 59| result |= section_result; 2923| 59| break; 2924| 470| case BinarySection::Function: ------------------ | Branch (2924:7): [True: 470, False: 1.99M] ------------------ 2925| 470| section_result = ReadFunctionSection(section_size); 2926| 470| result |= section_result; 2927| 470| break; 2928| 175| case BinarySection::Table: ------------------ | Branch (2928:7): [True: 175, False: 1.99M] ------------------ 2929| 175| section_result = ReadTableSection(section_size); 2930| 175| result |= section_result; 2931| 175| break; 2932| 277| case BinarySection::Memory: ------------------ | Branch (2932:7): [True: 277, False: 1.99M] ------------------ 2933| 277| section_result = ReadMemorySection(section_size); 2934| 277| result |= section_result; 2935| 277| break; 2936| 84| case BinarySection::Global: ------------------ | Branch (2936:7): [True: 84, False: 1.99M] ------------------ 2937| 84| section_result = ReadGlobalSection(section_size); 2938| 84| result |= section_result; 2939| 84| break; 2940| 355| case BinarySection::Export: ------------------ | Branch (2940:7): [True: 355, False: 1.99M] ------------------ 2941| 355| section_result = ReadExportSection(section_size); 2942| 355| result |= section_result; 2943| 355| break; 2944| 18| case BinarySection::Start: ------------------ | Branch (2944:7): [True: 18, False: 1.99M] ------------------ 2945| 18| section_result = ReadStartSection(section_size); 2946| 18| result |= section_result; 2947| 18| break; 2948| 43| case BinarySection::Elem: ------------------ | Branch (2948:7): [True: 43, False: 1.99M] ------------------ 2949| 43| section_result = ReadElemSection(section_size); 2950| 43| result |= section_result; 2951| 43| break; 2952| 387| case BinarySection::Code: ------------------ | Branch (2952:7): [True: 387, False: 1.99M] ------------------ 2953| 387| section_result = ReadCodeSection(section_size); 2954| 387| result |= section_result; 2955| 387| break; 2956| 20| case BinarySection::Data: ------------------ | Branch (2956:7): [True: 20, False: 1.99M] ------------------ 2957| 20| section_result = ReadDataSection(section_size); 2958| 20| result |= section_result; 2959| 20| break; 2960| 10| case BinarySection::Tag: ------------------ | Branch (2960:7): [True: 10, False: 1.99M] ------------------ 2961| 10| ERROR_UNLESS(options_.features.exceptions_enabled(), ------------------ | | 48| 10|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 10| do { \ | | | | 42| 10| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 1, False: 9] | | | | ------------------ | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | 44| 1| return Result::Error; \ | | | | 45| 1| } \ | | | | 46| 10| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2962| 9| "invalid section code: %u", 2963| 9| static_cast(section)); 2964| 9| section_result = ReadTagSection(section_size); 2965| 9| result |= section_result; 2966| 9| break; 2967| 2| case BinarySection::DataCount: ------------------ | Branch (2967:7): [True: 2, False: 1.99M] ------------------ 2968| 2| ERROR_UNLESS(options_.features.bulk_memory_enabled(), ------------------ | | 48| 2|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 2| do { \ | | | | 42| 2| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 2] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 2| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2969| 2| "invalid section code: %u", 2970| 2| static_cast(section)); 2971| 2| section_result = ReadDataCountSection(section_size); 2972| 2| result |= section_result; 2973| 2| break; 2974| 0| case BinarySection::Invalid: ------------------ | Branch (2974:7): [True: 0, False: 1.99M] ------------------ 2975| 0| WABT_UNREACHABLE; ------------------ | | 112| 0|#define WABT_UNREACHABLE abort() ------------------ 2976| 1.99M| } 2977| | 2978| 1.99M| if (Succeeded(section_result) && state_.offset != read_end_) { ------------------ | Branch (2978:9): [True: 48.1k, False: 1.95M] | Branch (2978:38): [True: 2.19k, False: 45.9k] ------------------ 2979| 2.19k| PrintError("unfinished section (expected end: 0x%" PRIzx ")", read_end_); 2980| 2.19k| section_result = Result::Error; 2981| 2.19k| result |= section_result; 2982| 2.19k| } 2983| | 2984| 1.99M| if (Failed(section_result)) { ------------------ | Branch (2984:9): [True: 1.95M, False: 45.9k] ------------------ 2985| 1.95M| if (stop_on_first_error) { ------------------ | Branch (2985:11): [True: 0, False: 1.95M] ------------------ 2986| 0| return Result::Error; 2987| 0| } 2988| | 2989| | // If we're continuing after failing to read this section, move the 2990| | // offset to the expected section end. This way we may be able to read 2991| | // further sections. 2992| 1.95M| state_.offset = read_end_; 2993| 1.95M| } 2994| | 2995| 1.99M| if (section != BinarySection::Custom) { ------------------ | Branch (2995:9): [True: 2.42k, False: 1.99M] ------------------ 2996| 2.42k| last_known_section_ = section; 2997| 2.42k| } 2998| 1.99M| } 2999| | 3000| 465| return result; 3001| 956|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader6ReadU8EPhPKc: 294| 2.56M|Result BinaryReader::ReadU8(uint8_t* out_value, const char* desc) { 295| 2.56M| return ReadT(out_value, "uint8_t", desc); 296| 2.56M|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader5ReadTIhEENS_6ResultEPT_PKcS7_: 277| 2.56M| const char* desc) { 278| 2.56M| if (state_.offset + sizeof(T) > read_end_) { ------------------ | Branch (278:7): [True: 1.41k, False: 2.56M] ------------------ 279| 1.41k| PrintError("unable to read %s: %s", type_name, desc); 280| 1.41k| return Result::Error; 281| 1.41k| } 282| |#if WABT_BIG_ENDIAN 283| | uint8_t tmp[sizeof(T)]; 284| | memcpy(tmp, state_.data + state_.offset, sizeof(tmp)); 285| | SwapBytesSized(tmp, sizeof(tmp)); 286| | memcpy(out_value, tmp, sizeof(T)); 287| |#else 288| 2.56M| memcpy(out_value, state_.data + state_.offset, sizeof(T)); 289| 2.56M|#endif 290| 2.56M| state_.offset += sizeof(T); 291| 2.56M| return Result::Ok; 292| 2.56M|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader10ReadOffsetEPmPKc: 425| 2.29M|Result BinaryReader::ReadOffset(Offset* offset, const char* desc) { 426| 2.29M| uint32_t value; 427| 2.29M| CHECK_RESULT(ReadU32Leb128(&value, desc)); ------------------ | | 55| 2.29M| do { \ | | 56| 2.29M| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5.61k, False: 2.28M] | | ------------------ | | 57| 5.61k| return ::wabt::Result::Error; \ | | 58| 5.61k| } \ | | 59| 2.29M| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 428| 2.28M| *offset = value; 429| 2.28M| return Result::Ok; 430| 2.29M|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader13ReadU32Leb128EPjPKc: 314| 5.09M|Result BinaryReader::ReadU32Leb128(uint32_t* out_value, const char* desc) { 315| 5.09M| const uint8_t* p = state_.data + state_.offset; 316| 5.09M| const uint8_t* end = state_.data + read_end_; 317| 5.09M| size_t bytes_read = wabt::ReadU32Leb128(p, end, out_value); 318| 5.09M| ERROR_UNLESS(bytes_read > 0, "unable to read u32 leb128: %s", desc); ------------------ | | 48| 5.09M|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 5.09M| do { \ | | | | 42| 5.09M| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 1.91M, False: 3.18M] | | | | ------------------ | | | | 43| 1.91M| PrintError(__VA_ARGS__); \ | | | | 44| 1.91M| return Result::Error; \ | | | | 45| 1.91M| } \ | | | | 46| 5.09M| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 319| 3.18M| state_.offset += bytes_read; 320| 3.18M| return Result::Ok; 321| 5.09M|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ValueRestoreGuardImXadL_ZNS1_9read_end_EEEEC2EPS1_: 85| 2.26M| : this_(this_), previous_value_(this_->*member) {} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ReadCustomSectionEjm: 2396| 1.99M| Offset section_size) { 2397| 1.99M| std::string_view section_name; 2398| 1.99M| CHECK_RESULT(ReadStr(§ion_name, "section name")); ------------------ | | 55| 1.99M| do { \ | | 56| 1.99M| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1.88M, False: 106k] | | ------------------ | | 57| 1.88M| return ::wabt::Result::Error; \ | | 58| 1.88M| } \ | | 59| 1.99M| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2399| 106k| CALLBACK(BeginCustomSection, section_index, section_size, section_name); ------------------ | | 61| 106k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 106k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 106k| do { \ | | | | | | 42| 106k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 106k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 106k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 106k| #member " callback failed") ------------------ 2400| 106k| ValueRestoreGuard guard(this); 2401| 106k| reading_custom_section_ = true; 2402| | 2403| 106k| { 2404| | // Backtrack parser when scope ends 2405| 106k| ValueRestoreGuard guard( 2406| 106k| this); 2407| 106k| CHECK_RESULT(ReadGenericCustomSection(section_name, section_size)); ------------------ | | 55| 106k| do { \ | | 56| 106k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 106k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 106k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2408| 106k| } 2409| | 2410| 106k| if (options_.read_debug_names && section_name == WABT_BINARY_SECTION_NAME) { ------------------ | | 31| 0|#define WABT_BINARY_SECTION_NAME "name" ------------------ | Branch (2410:7): [True: 0, False: 106k] | Branch (2410:36): [True: 0, False: 0] ------------------ 2411| 0| CHECK_RESULT(ReadNameSection(section_size)); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2412| 0| did_read_names_section_ = true; 2413| 106k| } else if (section_name == WABT_BINARY_SECTION_DYLINK0) { ------------------ | | 36| 106k|#define WABT_BINARY_SECTION_DYLINK0 "dylink.0" ------------------ | Branch (2413:14): [True: 24.2k, False: 82.0k] ------------------ 2414| 24.2k| CHECK_RESULT(ReadDylink0Section(section_size)); ------------------ | | 55| 24.2k| do { \ | | 56| 24.2k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 23.7k, False: 473] | | ------------------ | | 57| 23.7k| return ::wabt::Result::Error; \ | | 58| 23.7k| } \ | | 59| 24.2k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2415| 82.0k| } else if (section_name == WABT_BINARY_SECTION_DYLINK) { ------------------ | | 35| 82.0k|#define WABT_BINARY_SECTION_DYLINK "dylink" ------------------ | Branch (2415:14): [True: 1.48k, False: 80.5k] ------------------ 2416| 1.48k| CHECK_RESULT(ReadDylinkSection(section_size)); ------------------ | | 55| 1.48k| do { \ | | 56| 1.48k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 805, False: 677] | | ------------------ | | 57| 805| return ::wabt::Result::Error; \ | | 58| 805| } \ | | 59| 1.48k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2417| 80.5k| } else if (section_name.rfind(WABT_BINARY_SECTION_RELOC, 0) == 0) { ------------------ | | 32| 80.5k|#define WABT_BINARY_SECTION_RELOC "reloc" ------------------ | Branch (2417:14): [True: 8.43k, False: 72.1k] ------------------ 2418| | // Reloc sections always begin with "reloc." 2419| 8.43k| CHECK_RESULT(ReadRelocSection(section_size)); ------------------ | | 55| 8.43k| do { \ | | 56| 8.43k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 7.16k, False: 1.27k] | | ------------------ | | 57| 7.16k| return ::wabt::Result::Error; \ | | 58| 7.16k| } \ | | 59| 8.43k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2420| 72.1k| } else if (section_name == WABT_BINARY_SECTION_TARGET_FEATURES) { ------------------ | | 34| 72.1k|#define WABT_BINARY_SECTION_TARGET_FEATURES "target_features" ------------------ | Branch (2420:14): [True: 2.85k, False: 69.2k] ------------------ 2421| 2.85k| CHECK_RESULT(ReadTargetFeaturesSections(section_size)); ------------------ | | 55| 2.85k| do { \ | | 56| 2.85k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2.28k, False: 576] | | ------------------ | | 57| 2.28k| return ::wabt::Result::Error; \ | | 58| 2.28k| } \ | | 59| 2.85k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2422| 69.2k| } else if (section_name == WABT_BINARY_SECTION_LINKING) { ------------------ | | 33| 69.2k|#define WABT_BINARY_SECTION_LINKING "linking" ------------------ | Branch (2422:14): [True: 22.6k, False: 46.6k] ------------------ 2423| 22.6k| CHECK_RESULT(ReadLinkingSection(section_size)); ------------------ | | 55| 22.6k| do { \ | | 56| 22.6k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 22.1k, False: 477] | | ------------------ | | 57| 22.1k| return ::wabt::Result::Error; \ | | 58| 22.1k| } \ | | 59| 22.6k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2424| 46.6k| } else if (options_.features.code_metadata_enabled() && ------------------ | Branch (2424:14): [True: 11.8k, False: 34.7k] ------------------ 2425| 46.6k| section_name.find(WABT_BINARY_SECTION_CODE_METADATA) == 0) { ------------------ | | 37| 11.8k|#define WABT_BINARY_SECTION_CODE_METADATA "metadata.code." ------------------ | Branch (2425:14): [True: 3.49k, False: 8.35k] ------------------ 2426| 3.49k| std::string_view metadata_name = section_name; 2427| 3.49k| metadata_name.remove_prefix(sizeof(WABT_BINARY_SECTION_CODE_METADATA) - 1); ------------------ | | 37| 3.49k|#define WABT_BINARY_SECTION_CODE_METADATA "metadata.code." ------------------ 2428| 3.49k| CHECK_RESULT(ReadCodeMetadataSection(metadata_name, section_size)); ------------------ | | 55| 3.49k| do { \ | | 56| 3.49k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 3.22k, False: 267] | | ------------------ | | 57| 3.22k| return ::wabt::Result::Error; \ | | 58| 3.22k| } \ | | 59| 3.49k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2429| 43.1k| } else { 2430| | // Skip. This is a generic custom section, and is handled above. 2431| 43.1k| state_.offset = read_end_; 2432| 43.1k| } 2433| 46.8k| CALLBACK0(EndCustomSection); ------------------ | | 58| 46.8k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 46.8k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 46.8k| do { \ | | | | | | 42| 46.8k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 46.8k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 46.8k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2434| 46.8k| return Result::Ok; 2435| 46.8k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader7ReadStrEPNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPKc: 381| 2.09M|Result BinaryReader::ReadStr(std::string_view* out_str, const char* desc) { 382| 2.09M| uint32_t str_len = 0; 383| 2.09M| CHECK_RESULT(ReadU32Leb128(&str_len, "string length")); ------------------ | | 55| 2.09M| do { \ | | 56| 2.09M| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1.88M, False: 206k] | | ------------------ | | 57| 1.88M| return ::wabt::Result::Error; \ | | 58| 1.88M| } \ | | 59| 2.09M| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 384| | 385| 206k| ERROR_UNLESS(state_.offset + str_len <= read_end_, ------------------ | | 48| 206k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 206k| do { \ | | | | 42| 206k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 2.74k, False: 203k] | | | | ------------------ | | | | 43| 2.74k| PrintError(__VA_ARGS__); \ | | | | 44| 2.74k| return Result::Error; \ | | | | 45| 2.74k| } \ | | | | 46| 206k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 386| 203k| "unable to read string: %s", desc); 387| | 388| 203k| *out_str = std::string_view( 389| 203k| reinterpret_cast(state_.data) + state_.offset, str_len); 390| 203k| state_.offset += str_len; 391| | 392| 203k| ERROR_UNLESS(IsValidUtf8(out_str->data(), out_str->length()), ------------------ | | 48| 203k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 203k| do { \ | | | | 42| 203k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 4.62k, False: 198k] | | | | ------------------ | | | | 43| 4.62k| PrintError(__VA_ARGS__); \ | | | | 44| 4.62k| return Result::Error; \ | | | | 45| 4.62k| } \ | | | | 46| 203k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 393| 198k| "invalid utf-8 encoding: %s", desc); 394| 198k| return Result::Ok; 395| 203k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ValueRestoreGuardIbXadL_ZNS1_23reading_custom_section_EEEEC2EPS1_: 85| 106k| : this_(this_), previous_value_(this_->*member) {} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ValueRestoreGuardINS_20BinaryReaderDelegate5StateEXadL_ZNS1_6state_EEEEC2EPS1_: 85| 106k| : this_(this_), previous_value_(this_->*member) {} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader24ReadGenericCustomSectionENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEm: 2172| 106k| Offset section_size) { 2173| 106k| CALLBACK(BeginGenericCustomSection, section_size); ------------------ | | 61| 106k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 106k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 106k| do { \ | | | | | | 42| 106k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 106k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 106k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 106k| #member " callback failed") ------------------ 2174| 106k| const void* data; 2175| 106k| Offset custom_data_size = read_end_ - state_.offset; 2176| 106k| CHECK_RESULT( ------------------ | | 55| 106k| do { \ | | 56| 106k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 106k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 106k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2177| 106k| ReadBytesWithSize(&data, custom_data_size, "custom section data")); 2178| 106k| CALLBACK(OnGenericCustomSection, name, data, custom_data_size); ------------------ | | 61| 106k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 106k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 106k| do { \ | | | | | | 42| 106k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 106k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 106k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 106k| #member " callback failed") ------------------ 2179| 106k| CALLBACK0(EndGenericCustomSection); ------------------ | | 58| 106k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 106k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 106k| do { \ | | | | | | 42| 106k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 106k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 106k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2180| 106k| return Result::Ok; 2181| 106k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ReadBytesWithSizeEPPKvmPKc: 409| 108k| const char* desc) { 410| 108k| ERROR_UNLESS(state_.offset + size <= read_end_, "unable to read data: %s", ------------------ | | 48| 108k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 108k| do { \ | | | | 42| 108k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 129, False: 108k] | | | | ------------------ | | | | 43| 129| PrintError(__VA_ARGS__); \ | | | | 44| 129| return Result::Error; \ | | | | 45| 129| } \ | | | | 46| 108k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 411| 108k| desc); 412| | 413| 108k| *out_data = static_cast(state_.data) + state_.offset; 414| 108k| state_.offset += size; 415| 108k| return Result::Ok; 416| 108k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ValueRestoreGuardINS_20BinaryReaderDelegate5StateEXadL_ZNS1_6state_EEEED2Ev: 86| 106k| ~ValueRestoreGuard() { this_->*member = previous_value_; } binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader9ReadCountEPjPKc: 495| 29.8k|Result BinaryReader::ReadCount(Index* count, const char* desc) { 496| 29.8k| CHECK_RESULT(ReadIndex(count, desc)); ------------------ | | 55| 29.8k| do { \ | | 56| 29.8k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 507, False: 29.3k] | | ------------------ | | 57| 507| return ::wabt::Result::Error; \ | | 58| 507| } \ | | 59| 29.8k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 497| | 498| | // This check assumes that each item follows in this section, and takes at 499| | // least 1 byte. It's possible that this check passes but reading fails 500| | // later. It is still useful to check here, though, because it early-outs 501| | // when an erroneous large count is used, before allocating memory for it. 502| 29.3k| size_t section_remaining = read_end_ - state_.offset; 503| 29.3k| if (*count > section_remaining) { ------------------ | Branch (503:7): [True: 1.36k, False: 27.9k] ------------------ 504| 1.36k| PrintError("invalid %s %" PRIindex ", only %" PRIzd 505| 1.36k| " bytes left in section", 506| 1.36k| desc, *count, section_remaining); 507| 1.36k| return Result::Error; 508| 1.36k| } 509| 27.9k| return Result::Ok; 510| 29.3k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader9ReadIndexEPjPKc: 418| 78.5k|Result BinaryReader::ReadIndex(Index* index, const char* desc) { 419| 78.5k| uint32_t value; 420| 78.5k| CHECK_RESULT(ReadU32Leb128(&value, desc)); ------------------ | | 55| 78.5k| do { \ | | 56| 78.5k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1.61k, False: 76.9k] | | ------------------ | | 57| 1.61k| return ::wabt::Result::Error; \ | | 58| 1.61k| } \ | | 59| 78.5k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 421| 76.9k| *index = value; 422| 76.9k| return Result::Ok; 423| 78.5k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader13NumTotalFuncsEv: 563| 4.60k|Index BinaryReader::NumTotalFuncs() { 564| 4.60k| return num_func_imports_ + num_function_signatures_; 565| 4.60k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader18ReadDylink0SectionEm: 2053| 24.2k|Result BinaryReader::ReadDylink0Section(Offset section_size) { 2054| 24.2k| CALLBACK(BeginDylinkSection, section_size); ------------------ | | 61| 24.2k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 24.2k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 24.2k| do { \ | | | | | | 42| 24.2k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 24.2k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 24.2k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 24.2k| #member " callback failed") ------------------ 2055| | 2056| 26.9k| while (state_.offset < read_end_) { ------------------ | Branch (2056:10): [True: 26.4k, False: 473] ------------------ 2057| 26.4k| uint32_t dylink_type; 2058| 26.4k| Offset subsection_size; 2059| 26.4k| CHECK_RESULT(ReadU32Leb128(&dylink_type, "type")); ------------------ | | 55| 26.4k| do { \ | | 56| 26.4k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 172, False: 26.2k] | | ------------------ | | 57| 172| return ::wabt::Result::Error; \ | | 58| 172| } \ | | 59| 26.4k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2060| 26.2k| CHECK_RESULT(ReadOffset(&subsection_size, "subsection size")); ------------------ | | 55| 26.2k| do { \ | | 56| 26.2k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 457, False: 25.8k] | | ------------------ | | 57| 457| return ::wabt::Result::Error; \ | | 58| 457| } \ | | 59| 26.2k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2061| 25.8k| size_t subsection_end = state_.offset + subsection_size; 2062| 25.8k| ERROR_UNLESS(subsection_end <= read_end_, ------------------ | | 48| 25.8k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 25.8k| do { \ | | | | 42| 25.8k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 317, False: 25.4k] | | | | ------------------ | | | | 43| 317| PrintError(__VA_ARGS__); \ | | | | 44| 317| return Result::Error; \ | | | | 45| 317| } \ | | | | 46| 25.8k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2063| 25.4k| "invalid sub-section size: extends past end"); 2064| 25.4k| ReadEndRestoreGuard guard(this); 2065| 25.4k| read_end_ = subsection_end; 2066| | 2067| 25.4k| uint32_t count; 2068| 25.4k| switch (static_cast(dylink_type)) { 2069| 21.5k| case DylinkEntryType::MemInfo: { ------------------ | Branch (2069:7): [True: 21.5k, False: 3.95k] ------------------ 2070| 21.5k| uint32_t mem_size; 2071| 21.5k| uint32_t mem_align; 2072| 21.5k| uint32_t table_size; 2073| 21.5k| uint32_t table_align; 2074| | 2075| 21.5k| CHECK_RESULT(ReadU32Leb128(&mem_size, "mem_size")); ------------------ | | 55| 21.5k| do { \ | | 56| 21.5k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 163, False: 21.3k] | | ------------------ | | 57| 163| return ::wabt::Result::Error; \ | | 58| 163| } \ | | 59| 21.5k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2076| 21.3k| CHECK_RESULT(ReadU32Leb128(&mem_align, "mem_align")); ------------------ | | 55| 21.3k| do { \ | | 56| 21.3k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2.04k, False: 19.3k] | | ------------------ | | 57| 2.04k| return ::wabt::Result::Error; \ | | 58| 2.04k| } \ | | 59| 21.3k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2077| 19.3k| CHECK_RESULT(ReadU32Leb128(&table_size, "table_size")); ------------------ | | 55| 19.3k| do { \ | | 56| 19.3k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 33, False: 19.3k] | | ------------------ | | 57| 33| return ::wabt::Result::Error; \ | | 58| 33| } \ | | 59| 19.3k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2078| 19.3k| CHECK_RESULT(ReadU32Leb128(&table_align, "table_align")); ------------------ | | 55| 19.3k| do { \ | | 56| 19.3k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 8.58k, False: 10.7k] | | ------------------ | | 57| 8.58k| return ::wabt::Result::Error; \ | | 58| 8.58k| } \ | | 59| 19.3k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2079| 10.7k| CALLBACK(OnDylinkInfo, mem_size, mem_align, table_size, table_align); ------------------ | | 61| 10.7k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 10.7k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 10.7k| do { \ | | | | | | 42| 10.7k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 10.7k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 10.7k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 10.7k| #member " callback failed") ------------------ 2080| 10.7k| break; 2081| 10.7k| } 2082| 10.7k| case DylinkEntryType::Needed: ------------------ | Branch (2082:7): [True: 407, False: 25.0k] ------------------ 2083| 407| CHECK_RESULT(ReadU32Leb128(&count, "needed_dynlibs")); ------------------ | | 55| 407| do { \ | | 56| 407| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 33, False: 374] | | ------------------ | | 57| 33| return ::wabt::Result::Error; \ | | 58| 33| } \ | | 59| 407| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2084| 374| CALLBACK(OnDylinkNeededCount, count); ------------------ | | 61| 374| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 374|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 374| do { \ | | | | | | 42| 374| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 374] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 374| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 374| #member " callback failed") ------------------ 2085| 532| while (count--) { ------------------ | Branch (2085:16): [True: 293, False: 239] ------------------ 2086| 293| std::string_view so_name; 2087| 293| CHECK_RESULT(ReadStr(&so_name, "dylib so_name")); ------------------ | | 55| 293| do { \ | | 56| 293| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 135, False: 158] | | ------------------ | | 57| 135| return ::wabt::Result::Error; \ | | 58| 135| } \ | | 59| 293| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2088| 158| CALLBACK(OnDylinkNeeded, so_name); ------------------ | | 61| 158| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 158|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 158| do { \ | | | | | | 42| 158| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 158] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 158| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 158| #member " callback failed") ------------------ 2089| 158| } 2090| 239| break; 2091| 1.41k| case DylinkEntryType::ImportInfo: ------------------ | Branch (2091:7): [True: 1.41k, False: 24.0k] ------------------ 2092| 1.41k| CHECK_RESULT(ReadU32Leb128(&count, "count")); ------------------ | | 55| 1.41k| do { \ | | 56| 1.41k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 438, False: 972] | | ------------------ | | 57| 438| return ::wabt::Result::Error; \ | | 58| 438| } \ | | 59| 1.41k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2093| 972| CALLBACK(OnDylinkImportCount, count); ------------------ | | 61| 972| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 972|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 972| do { \ | | | | | | 42| 972| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 972] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 972| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 972| #member " callback failed") ------------------ 2094| 1.13k| for (Index i = 0; i < count; ++i) { ------------------ | Branch (2094:27): [True: 809, False: 323] ------------------ 2095| 809| uint32_t flags = 0; 2096| 809| std::string_view module; 2097| 809| std::string_view field; 2098| 809| CHECK_RESULT(ReadStr(&module, "module")); ------------------ | | 55| 809| do { \ | | 56| 809| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 167, False: 642] | | ------------------ | | 57| 167| return ::wabt::Result::Error; \ | | 58| 167| } \ | | 59| 809| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2099| 642| CHECK_RESULT(ReadStr(&field, "field")); ------------------ | | 55| 642| do { \ | | 56| 642| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 164, False: 478] | | ------------------ | | 57| 164| return ::wabt::Result::Error; \ | | 58| 164| } \ | | 59| 642| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2100| 478| CHECK_RESULT(ReadU32Leb128(&flags, "flags")); ------------------ | | 55| 478| do { \ | | 56| 478| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 318, False: 160] | | ------------------ | | 57| 318| return ::wabt::Result::Error; \ | | 58| 318| } \ | | 59| 478| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2101| 160| CALLBACK(OnDylinkImport, module, field, flags); ------------------ | | 61| 160| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 160|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 160| do { \ | | | | | | 42| 160| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 160] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 160| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 160| #member " callback failed") ------------------ 2102| 160| } 2103| 323| break; 2104| 439| case DylinkEntryType::ExportInfo: ------------------ | Branch (2104:7): [True: 439, False: 25.0k] ------------------ 2105| 439| CHECK_RESULT(ReadU32Leb128(&count, "count")); ------------------ | | 55| 439| do { \ | | 56| 439| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 33, False: 406] | | ------------------ | | 57| 33| return ::wabt::Result::Error; \ | | 58| 33| } \ | | 59| 439| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2106| 406| CALLBACK(OnDylinkExportCount, count); ------------------ | | 61| 406| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 406|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 406| do { \ | | | | | | 42| 406| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 406] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 406| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 406| #member " callback failed") ------------------ 2107| 566| for (Index i = 0; i < count; ++i) { ------------------ | Branch (2107:27): [True: 374, False: 192] ------------------ 2108| 374| uint32_t flags = 0; 2109| 374| std::string_view name; 2110| 374| CHECK_RESULT(ReadStr(&name, "name")); ------------------ | | 55| 374| do { \ | | 56| 374| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 164, False: 210] | | ------------------ | | 57| 164| return ::wabt::Result::Error; \ | | 58| 164| } \ | | 59| 374| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2111| 210| CHECK_RESULT(ReadU32Leb128(&flags, "flags")); ------------------ | | 55| 210| do { \ | | 56| 210| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 50, False: 160] | | ------------------ | | 57| 50| return ::wabt::Result::Error; \ | | 58| 50| } \ | | 59| 210| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2112| 160| CALLBACK(OnDylinkExport, name, flags); ------------------ | | 61| 160| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 160|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 160| do { \ | | | | | | 42| 160| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 160] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 160| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 160| #member " callback failed") ------------------ 2113| 160| } 2114| 192| break; 2115| 1.69k| default: ------------------ | Branch (2115:7): [True: 1.69k, False: 23.8k] ------------------ 2116| | // Unknown subsection, skip it. 2117| 1.69k| state_.offset = subsection_end; 2118| 1.69k| break; 2119| 25.4k| } 2120| 13.1k| ERROR_UNLESS(state_.offset == subsection_end, ------------------ | | 48| 13.1k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 13.1k| do { \ | | | | 42| 13.1k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 10.4k, False: 2.70k] | | | | ------------------ | | | | 43| 10.4k| PrintError(__VA_ARGS__); \ | | | | 44| 10.4k| return Result::Error; \ | | | | 45| 10.4k| } \ | | | | 46| 13.1k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2121| 13.1k| "unfinished sub-section (expected end: 0x%" PRIzx ")", 2122| 13.1k| subsection_end); 2123| 13.1k| } 2124| | 2125| 473| CALLBACK0(EndDylinkSection); ------------------ | | 58| 473| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 473|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 473| do { \ | | | | | | 42| 473| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 473] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 473| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2126| 473| return Result::Ok; 2127| 473|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ReadDylinkSectionEm: 2129| 1.48k|Result BinaryReader::ReadDylinkSection(Offset section_size) { 2130| 1.48k| CALLBACK(BeginDylinkSection, section_size); ------------------ | | 61| 1.48k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.48k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.48k| do { \ | | | | | | 42| 1.48k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.48k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.48k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.48k| #member " callback failed") ------------------ 2131| 1.48k| uint32_t mem_size; 2132| 1.48k| uint32_t mem_align; 2133| 1.48k| uint32_t table_size; 2134| 1.48k| uint32_t table_align; 2135| | 2136| 1.48k| CHECK_RESULT(ReadU32Leb128(&mem_size, "mem_size")); ------------------ | | 55| 1.48k| do { \ | | 56| 1.48k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 128, False: 1.35k] | | ------------------ | | 57| 128| return ::wabt::Result::Error; \ | | 58| 128| } \ | | 59| 1.48k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2137| 1.35k| CHECK_RESULT(ReadU32Leb128(&mem_align, "mem_align")); ------------------ | | 55| 1.35k| do { \ | | 56| 1.35k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 128, False: 1.22k] | | ------------------ | | 57| 128| return ::wabt::Result::Error; \ | | 58| 128| } \ | | 59| 1.35k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2138| 1.22k| CHECK_RESULT(ReadU32Leb128(&table_size, "table_size")); ------------------ | | 55| 1.22k| do { \ | | 56| 1.22k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 1.22k] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 1.22k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2139| 1.22k| CHECK_RESULT(ReadU32Leb128(&table_align, "table_align")); ------------------ | | 55| 1.22k| do { \ | | 56| 1.22k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 1.22k] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 1.22k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2140| 1.22k| CALLBACK(OnDylinkInfo, mem_size, mem_align, table_size, table_align); ------------------ | | 61| 1.22k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.22k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.22k| do { \ | | | | | | 42| 1.22k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.22k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.22k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.22k| #member " callback failed") ------------------ 2141| | 2142| 1.22k| uint32_t count; 2143| 1.22k| CHECK_RESULT(ReadU32Leb128(&count, "needed_dynlibs")); ------------------ | | 55| 1.22k| do { \ | | 56| 1.22k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 189, False: 1.03k] | | ------------------ | | 57| 189| return ::wabt::Result::Error; \ | | 58| 189| } \ | | 59| 1.22k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2144| 1.03k| CALLBACK(OnDylinkNeededCount, count); ------------------ | | 61| 1.03k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.03k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.03k| do { \ | | | | | | 42| 1.03k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.03k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.03k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.03k| #member " callback failed") ------------------ 2145| 1.32k| while (count--) { ------------------ | Branch (2145:10): [True: 651, False: 677] ------------------ 2146| 651| std::string_view so_name; 2147| 651| CHECK_RESULT(ReadStr(&so_name, "dylib so_name")); ------------------ | | 55| 651| do { \ | | 56| 651| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 358, False: 293] | | ------------------ | | 57| 358| return ::wabt::Result::Error; \ | | 58| 358| } \ | | 59| 651| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2148| 293| CALLBACK(OnDylinkNeeded, so_name); ------------------ | | 61| 293| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 293|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 293| do { \ | | | | | | 42| 293| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 293] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 293| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 293| #member " callback failed") ------------------ 2149| 293| } 2150| | 2151| 677| CALLBACK0(EndDylinkSection); ------------------ | | 58| 677| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 677|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 677| do { \ | | | | | | 42| 677| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 677] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 677| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2152| 677| return Result::Ok; 2153| 677|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader16ReadRelocSectionEm: 1999| 8.43k|Result BinaryReader::ReadRelocSection(Offset section_size) { 2000| 8.43k| CALLBACK(BeginRelocSection, section_size); ------------------ | | 61| 8.43k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 8.43k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 8.43k| do { \ | | | | | | 42| 8.43k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 8.43k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 8.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 8.43k| #member " callback failed") ------------------ 2001| 8.43k| uint32_t section_index; 2002| 8.43k| CHECK_RESULT(ReadU32Leb128(§ion_index, "section index")); ------------------ | | 55| 8.43k| do { \ | | 56| 8.43k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 255, False: 8.18k] | | ------------------ | | 57| 255| return ::wabt::Result::Error; \ | | 58| 255| } \ | | 59| 8.43k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2003| 8.18k| Index num_relocs; 2004| 8.18k| CHECK_RESULT(ReadCount(&num_relocs, "relocation count")); ------------------ | | 55| 8.18k| do { \ | | 56| 8.18k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 500, False: 7.68k] | | ------------------ | | 57| 500| return ::wabt::Result::Error; \ | | 58| 500| } \ | | 59| 8.18k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2005| 7.68k| CALLBACK(OnRelocCount, num_relocs, section_index); ------------------ | | 61| 7.68k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 7.68k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 7.68k| do { \ | | | | | | 42| 7.68k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 7.68k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 7.68k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 7.68k| #member " callback failed") ------------------ 2006| 26.7k| for (Index i = 0; i < num_relocs; ++i) { ------------------ | Branch (2006:21): [True: 25.5k, False: 1.27k] ------------------ 2007| 25.5k| Offset offset; 2008| 25.5k| Index index; 2009| 25.5k| uint32_t reloc_type, addend = 0; 2010| 25.5k| CHECK_RESULT(ReadU32Leb128(&reloc_type, "relocation type")); ------------------ | | 55| 25.5k| do { \ | | 56| 25.5k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 705, False: 24.8k] | | ------------------ | | 57| 705| return ::wabt::Result::Error; \ | | 58| 705| } \ | | 59| 25.5k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2011| 24.8k| CHECK_RESULT(ReadOffset(&offset, "offset")); ------------------ | | 55| 24.8k| do { \ | | 56| 24.8k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2.30k, False: 22.4k] | | ------------------ | | 57| 2.30k| return ::wabt::Result::Error; \ | | 58| 2.30k| } \ | | 59| 24.8k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2012| 22.4k| CHECK_RESULT(ReadIndex(&index, "index")); ------------------ | | 55| 22.4k| do { \ | | 56| 22.4k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1.08k, False: 21.4k] | | ------------------ | | 57| 1.08k| return ::wabt::Result::Error; \ | | 58| 1.08k| } \ | | 59| 22.4k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2013| 21.4k| RelocType type = static_cast(reloc_type); 2014| 21.4k| switch (type) { 2015| 215| case RelocType::MemoryAddressLEB: ------------------ | Branch (2015:7): [True: 215, False: 21.1k] ------------------ 2016| 973| case RelocType::MemoryAddressLEB64: ------------------ | Branch (2016:7): [True: 758, False: 20.6k] ------------------ 2017| 4.90k| case RelocType::MemoryAddressSLEB: ------------------ | Branch (2017:7): [True: 3.93k, False: 17.4k] ------------------ 2018| 7.47k| case RelocType::MemoryAddressSLEB64: ------------------ | Branch (2018:7): [True: 2.56k, False: 18.8k] ------------------ 2019| 7.82k| case RelocType::MemoryAddressRelSLEB: ------------------ | Branch (2019:7): [True: 353, False: 21.0k] ------------------ 2020| 8.29k| case RelocType::MemoryAddressRelSLEB64: ------------------ | Branch (2020:7): [True: 463, False: 20.9k] ------------------ 2021| 9.06k| case RelocType::MemoryAddressI32: ------------------ | Branch (2021:7): [True: 771, False: 20.6k] ------------------ 2022| 12.4k| case RelocType::MemoryAddressI64: ------------------ | Branch (2022:7): [True: 3.43k, False: 17.9k] ------------------ 2023| 12.5k| case RelocType::FunctionOffsetI32: ------------------ | Branch (2023:7): [True: 34, False: 21.3k] ------------------ 2024| 14.2k| case RelocType::SectionOffsetI32: ------------------ | Branch (2024:7): [True: 1.74k, False: 19.6k] ------------------ 2025| 16.9k| case RelocType::MemoryAddressTLSSLEB: ------------------ | Branch (2025:7): [True: 2.71k, False: 18.6k] ------------------ 2026| 16.9k| case RelocType::MemoryAddressTLSI32: ------------------ | Branch (2026:7): [True: 1, False: 21.4k] ------------------ 2027| 16.9k| CHECK_RESULT(ReadS32Leb128(&addend, "addend")); ------------------ | | 55| 16.9k| do { \ | | 56| 16.9k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1.43k, False: 15.5k] | | ------------------ | | 57| 1.43k| return ::wabt::Result::Error; \ | | 58| 1.43k| } \ | | 59| 16.9k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2028| 15.5k| break; 2029| | 2030| 15.5k| case RelocType::FuncIndexLEB: ------------------ | Branch (2030:7): [True: 1.08k, False: 20.3k] ------------------ 2031| 2.13k| case RelocType::TableIndexSLEB: ------------------ | Branch (2031:7): [True: 1.04k, False: 20.3k] ------------------ 2032| 2.13k| case RelocType::TableIndexSLEB64: ------------------ | Branch (2032:7): [True: 0, False: 21.4k] ------------------ 2033| 2.36k| case RelocType::TableIndexI32: ------------------ | Branch (2033:7): [True: 232, False: 21.1k] ------------------ 2034| 2.36k| case RelocType::TableIndexI64: ------------------ | Branch (2034:7): [True: 0, False: 21.4k] ------------------ 2035| 2.76k| case RelocType::TypeIndexLEB: ------------------ | Branch (2035:7): [True: 400, False: 21.0k] ------------------ 2036| 2.90k| case RelocType::GlobalIndexLEB: ------------------ | Branch (2036:7): [True: 137, False: 21.2k] ------------------ 2037| 2.92k| case RelocType::GlobalIndexI32: ------------------ | Branch (2037:7): [True: 18, False: 21.3k] ------------------ 2038| 3.23k| case RelocType::TagIndexLEB: ------------------ | Branch (2038:7): [True: 316, False: 21.0k] ------------------ 2039| 3.38k| case RelocType::TableIndexRelSLEB: ------------------ | Branch (2039:7): [True: 147, False: 21.2k] ------------------ 2040| 3.54k| case RelocType::TableNumberLEB: ------------------ | Branch (2040:7): [True: 157, False: 21.2k] ------------------ 2041| 3.54k| break; 2042| | 2043| 876| default: ------------------ | Branch (2043:7): [True: 876, False: 20.5k] ------------------ 2044| 876| PrintError("unknown reloc type: %s", GetRelocTypeName(type)); 2045| 876| return Result::Error; 2046| 21.4k| } 2047| 19.1k| CALLBACK(OnReloc, type, offset, index, addend); ------------------ | | 61| 19.1k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 19.1k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 19.1k| do { \ | | | | | | 42| 19.1k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 19.1k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 19.1k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 19.1k| #member " callback failed") ------------------ 2048| 19.1k| } 2049| 1.27k| CALLBACK0(EndRelocSection); ------------------ | | 58| 1.27k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 1.27k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.27k| do { \ | | | | | | 42| 1.27k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.27k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.27k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2050| 1.27k| return Result::Ok; 2051| 1.27k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader13ReadS32Leb128EPjPKc: 332| 47.5k|Result BinaryReader::ReadS32Leb128(uint32_t* out_value, const char* desc) { 333| 47.5k| const uint8_t* p = state_.data + state_.offset; 334| 47.5k| const uint8_t* end = state_.data + read_end_; 335| 47.5k| size_t bytes_read = wabt::ReadS32Leb128(p, end, out_value); 336| 47.5k| ERROR_UNLESS(bytes_read > 0, "unable to read i32 leb128: %s", desc); ------------------ | | 48| 47.5k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 47.5k| do { \ | | | | 42| 47.5k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 1.45k, False: 46.1k] | | | | ------------------ | | | | 43| 1.45k| PrintError(__VA_ARGS__); \ | | | | 44| 1.45k| return Result::Error; \ | | | | 45| 1.45k| } \ | | | | 46| 47.5k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 337| 46.1k| state_.offset += bytes_read; 338| 46.1k| return Result::Ok; 339| 47.5k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader26ReadTargetFeaturesSectionsEm: 2155| 2.85k|Result BinaryReader::ReadTargetFeaturesSections(Offset section_size) { 2156| 2.85k| CALLBACK(BeginTargetFeaturesSection, section_size); ------------------ | | 61| 2.85k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2.85k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.85k| do { \ | | | | | | 42| 2.85k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2.85k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2.85k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2.85k| #member " callback failed") ------------------ 2157| 2.85k| uint32_t count; 2158| 2.85k| CHECK_RESULT(ReadU32Leb128(&count, "sym count")); ------------------ | | 55| 2.85k| do { \ | | 56| 2.85k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 2.85k] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 2.85k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2159| 2.85k| CALLBACK(OnFeatureCount, count); ------------------ | | 61| 2.85k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2.85k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.85k| do { \ | | | | | | 42| 2.85k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2.85k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2.85k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2.85k| #member " callback failed") ------------------ 2160| 8.12k| while (count--) { ------------------ | Branch (2160:10): [True: 7.54k, False: 576] ------------------ 2161| 7.54k| uint8_t prefix; 2162| 7.54k| std::string_view name; 2163| 7.54k| CHECK_RESULT(ReadU8(&prefix, "prefix")); ------------------ | | 55| 7.54k| do { \ | | 56| 7.54k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1.39k, False: 6.15k] | | ------------------ | | 57| 1.39k| return ::wabt::Result::Error; \ | | 58| 1.39k| } \ | | 59| 7.54k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2164| 6.15k| CHECK_RESULT(ReadStr(&name, "feature name")); ------------------ | | 55| 6.15k| do { \ | | 56| 6.15k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 887, False: 5.26k] | | ------------------ | | 57| 887| return ::wabt::Result::Error; \ | | 58| 887| } \ | | 59| 6.15k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2165| 5.26k| CALLBACK(OnFeature, prefix, name); ------------------ | | 61| 5.26k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 5.26k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 5.26k| do { \ | | | | | | 42| 5.26k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 5.26k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 5.26k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 5.26k| #member " callback failed") ------------------ 2166| 5.26k| } 2167| 576| CALLBACK0(EndTargetFeaturesSection); ------------------ | | 58| 576| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 576|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 576| do { \ | | | | | | 42| 576| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 576] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 576| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2168| 576| return Result::Ok; 2169| 576|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader18ReadLinkingSectionEm: 2183| 22.6k|Result BinaryReader::ReadLinkingSection(Offset section_size) { 2184| 22.6k| CALLBACK(BeginLinkingSection, section_size); ------------------ | | 61| 22.6k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 22.6k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 22.6k| do { \ | | | | | | 42| 22.6k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 22.6k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 22.6k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 22.6k| #member " callback failed") ------------------ 2185| 22.6k| uint32_t version; 2186| 22.6k| CHECK_RESULT(ReadU32Leb128(&version, "version")); ------------------ | | 55| 22.6k| do { \ | | 56| 22.6k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 129, False: 22.5k] | | ------------------ | | 57| 129| return ::wabt::Result::Error; \ | | 58| 129| } \ | | 59| 22.6k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2187| 22.5k| ERROR_UNLESS(version == 2, "invalid linking metadata version: %u", version); ------------------ | | 48| 22.5k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 22.5k| do { \ | | | | 42| 22.5k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 150, False: 22.3k] | | | | ------------------ | | | | 43| 150| PrintError(__VA_ARGS__); \ | | | | 44| 150| return Result::Error; \ | | | | 45| 150| } \ | | | | 46| 22.5k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2188| 73.0k| while (state_.offset < read_end_) { ------------------ | Branch (2188:10): [True: 72.5k, False: 477] ------------------ 2189| 72.5k| uint32_t linking_type; 2190| 72.5k| Offset subsection_size; 2191| 72.5k| CHECK_RESULT(ReadU32Leb128(&linking_type, "type")); ------------------ | | 55| 72.5k| do { \ | | 56| 72.5k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 327, False: 72.2k] | | ------------------ | | 57| 327| return ::wabt::Result::Error; \ | | 58| 327| } \ | | 59| 72.5k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2192| 72.2k| CHECK_RESULT(ReadOffset(&subsection_size, "subsection size")); ------------------ | | 55| 72.2k| do { \ | | 56| 72.2k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2.53k, False: 69.6k] | | ------------------ | | 57| 2.53k| return ::wabt::Result::Error; \ | | 58| 2.53k| } \ | | 59| 72.2k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2193| 69.6k| size_t subsection_end = state_.offset + subsection_size; 2194| 69.6k| ERROR_UNLESS(subsection_end <= read_end_, ------------------ | | 48| 69.6k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 69.6k| do { \ | | | | 42| 69.6k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 2.40k, False: 67.2k] | | | | ------------------ | | | | 43| 2.40k| PrintError(__VA_ARGS__); \ | | | | 44| 2.40k| return Result::Error; \ | | | | 45| 2.40k| } \ | | | | 46| 69.6k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2195| 67.2k| "invalid sub-section size: extends past end"); 2196| 67.2k| ReadEndRestoreGuard guard(this); 2197| 67.2k| read_end_ = subsection_end; 2198| | 2199| 67.2k| uint32_t count; 2200| 67.2k| switch (static_cast(linking_type)) { 2201| 2.61k| case LinkingEntryType::SymbolTable: ------------------ | Branch (2201:7): [True: 2.61k, False: 64.6k] ------------------ 2202| 2.61k| CHECK_RESULT(ReadU32Leb128(&count, "sym count")); ------------------ | | 55| 2.61k| do { \ | | 56| 2.61k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 166, False: 2.45k] | | ------------------ | | 57| 166| return ::wabt::Result::Error; \ | | 58| 166| } \ | | 59| 2.61k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2203| 2.45k| CALLBACK(OnSymbolCount, count); ------------------ | | 61| 2.45k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2.45k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.45k| do { \ | | | | | | 42| 2.45k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2.45k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2.45k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2.45k| #member " callback failed") ------------------ 2204| 5.80k| for (Index i = 0; i < count; ++i) { ------------------ | Branch (2204:27): [True: 5.11k, False: 683] ------------------ 2205| 5.11k| std::string_view name; 2206| 5.11k| uint32_t flags = 0; 2207| 5.11k| uint32_t kind = 0; 2208| 5.11k| CHECK_RESULT(ReadU32Leb128(&kind, "sym type")); ------------------ | | 55| 5.11k| do { \ | | 56| 5.11k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 337, False: 4.78k] | | ------------------ | | 57| 337| return ::wabt::Result::Error; \ | | 58| 337| } \ | | 59| 5.11k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2209| 4.78k| CHECK_RESULT(ReadU32Leb128(&flags, "sym flags")); ------------------ | | 55| 4.78k| do { \ | | 56| 4.78k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 111, False: 4.66k] | | ------------------ | | 57| 111| return ::wabt::Result::Error; \ | | 58| 111| } \ | | 59| 4.78k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2210| 4.66k| SymbolType sym_type = static_cast(kind); 2211| 4.66k| switch (sym_type) { ------------------ | Branch (2211:19): [True: 1.05k, False: 3.61k] ------------------ 2212| 833| case SymbolType::Function: ------------------ | Branch (2212:13): [True: 833, False: 3.83k] ------------------ 2213| 1.15k| case SymbolType::Global: ------------------ | Branch (2213:13): [True: 321, False: 4.34k] ------------------ 2214| 1.48k| case SymbolType::Tag: ------------------ | Branch (2214:13): [True: 332, False: 4.33k] ------------------ 2215| 2.05k| case SymbolType::Table: { ------------------ | Branch (2215:13): [True: 573, False: 4.09k] ------------------ 2216| 2.05k| uint32_t index = 0; 2217| 2.05k| CHECK_RESULT(ReadU32Leb128(&index, "index")); ------------------ | | 55| 2.05k| do { \ | | 56| 2.05k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 309, False: 1.75k] | | ------------------ | | 57| 309| return ::wabt::Result::Error; \ | | 58| 309| } \ | | 59| 2.05k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2218| 1.75k| if ((flags & WABT_SYMBOL_FLAG_UNDEFINED) == 0 || ------------------ | | 326| 1.75k|#define WABT_SYMBOL_FLAG_UNDEFINED 0x10 ------------------ | Branch (2218:19): [True: 743, False: 1.00k] ------------------ 2219| 1.75k| (flags & WABT_SYMBOL_FLAG_EXPLICIT_NAME) != 0) ------------------ | | 328| 1.00k|#define WABT_SYMBOL_FLAG_EXPLICIT_NAME 0x40 ------------------ | Branch (2219:19): [True: 522, False: 485] ------------------ 2220| 1.26k| CHECK_RESULT(ReadStr(&name, "symbol name")); ------------------ | | 55| 1.26k| do { \ | | 56| 1.26k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 267, False: 998] | | ------------------ | | 57| 267| return ::wabt::Result::Error; \ | | 58| 267| } \ | | 59| 1.26k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2221| 1.48k| switch (sym_type) { 2222| 627| case SymbolType::Function: ------------------ | Branch (2222:17): [True: 627, False: 856] ------------------ 2223| 627| CALLBACK(OnFunctionSymbol, i, flags, name, index); ------------------ | | 61| 627| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 627|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 627| do { \ | | | | | | 42| 627| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 627] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 627| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 627| #member " callback failed") ------------------ 2224| 627| break; 2225| 627| case SymbolType::Global: ------------------ | Branch (2225:17): [True: 317, False: 1.16k] ------------------ 2226| 317| CALLBACK(OnGlobalSymbol, i, flags, name, index); ------------------ | | 61| 317| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 317|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 317| do { \ | | | | | | 42| 317| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 317] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 317| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 317| #member " callback failed") ------------------ 2227| 317| break; 2228| 317| case SymbolType::Tag: ------------------ | Branch (2228:17): [True: 237, False: 1.24k] ------------------ 2229| 237| CALLBACK(OnTagSymbol, i, flags, name, index); ------------------ | | 61| 237| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 237|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 237| do { \ | | | | | | 42| 237| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 237] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 237| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 237| #member " callback failed") ------------------ 2230| 237| break; 2231| 302| case SymbolType::Table: ------------------ | Branch (2231:17): [True: 302, False: 1.18k] ------------------ 2232| 302| CALLBACK(OnTableSymbol, i, flags, name, index); ------------------ | | 61| 302| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 302|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 302| do { \ | | | | | | 42| 302| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 302] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 302| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 302| #member " callback failed") ------------------ 2233| 302| break; 2234| 302| default: ------------------ | Branch (2234:17): [True: 0, False: 1.48k] ------------------ 2235| 0| WABT_UNREACHABLE; ------------------ | | 112| 0|#define WABT_UNREACHABLE abort() ------------------ 2236| 1.48k| } 2237| 1.48k| break; 2238| 1.48k| } 2239| 1.48k| case SymbolType::Data: { ------------------ | Branch (2239:13): [True: 1.34k, False: 3.32k] ------------------ 2240| 1.34k| uint32_t segment = 0; 2241| 1.34k| uint32_t offset = 0; 2242| 1.34k| uint32_t size = 0; 2243| 1.34k| CHECK_RESULT(ReadStr(&name, "symbol name")); ------------------ | | 55| 1.34k| do { \ | | 56| 1.34k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 317, False: 1.03k] | | ------------------ | | 57| 317| return ::wabt::Result::Error; \ | | 58| 317| } \ | | 59| 1.34k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2244| 1.03k| if ((flags & WABT_SYMBOL_FLAG_UNDEFINED) == 0) { ------------------ | | 326| 1.03k|#define WABT_SYMBOL_FLAG_UNDEFINED 0x10 ------------------ | Branch (2244:19): [True: 431, False: 601] ------------------ 2245| 431| CHECK_RESULT(ReadU32Leb128(&segment, "segment")); ------------------ | | 55| 431| do { \ | | 56| 431| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 32, False: 399] | | ------------------ | | 57| 32| return ::wabt::Result::Error; \ | | 58| 32| } \ | | 59| 431| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2246| 399| CHECK_RESULT(ReadU32Leb128(&offset, "offset")); ------------------ | | 55| 399| do { \ | | 56| 399| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 35, False: 364] | | ------------------ | | 57| 35| return ::wabt::Result::Error; \ | | 58| 35| } \ | | 59| 399| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2247| 364| CHECK_RESULT(ReadU32Leb128(&size, "size")); ------------------ | | 55| 364| do { \ | | 56| 364| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 178, False: 186] | | ------------------ | | 57| 178| return ::wabt::Result::Error; \ | | 58| 178| } \ | | 59| 364| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2248| 364| } 2249| 787| CALLBACK(OnDataSymbol, i, flags, name, segment, offset, size); ------------------ | | 61| 787| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 787|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 787| do { \ | | | | | | 42| 787| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 787] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 787| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 787| #member " callback failed") ------------------ 2250| 787| break; 2251| 787| } 2252| 787| case SymbolType::Section: { ------------------ | Branch (2252:13): [True: 210, False: 4.45k] ------------------ 2253| 210| uint32_t index = 0; 2254| 210| CHECK_RESULT(ReadU32Leb128(&index, "index")); ------------------ | | 55| 210| do { \ | | 56| 210| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 183, False: 27] | | ------------------ | | 57| 183| return ::wabt::Result::Error; \ | | 58| 183| } \ | | 59| 210| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2255| 27| CALLBACK(OnSectionSymbol, i, flags, index); ------------------ | | 61| 27| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 27|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 27| do { \ | | | | | | 42| 27| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 27] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 27| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 27| #member " callback failed") ------------------ 2256| 27| break; 2257| 27| } 2258| 4.66k| } 2259| 4.66k| } 2260| 683| break; 2261| 1.40k| case LinkingEntryType::SegmentInfo: ------------------ | Branch (2261:7): [True: 1.40k, False: 65.8k] ------------------ 2262| 1.40k| CHECK_RESULT(ReadU32Leb128(&count, "info count")); ------------------ | | 55| 1.40k| do { \ | | 56| 1.40k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 182, False: 1.22k] | | ------------------ | | 57| 182| return ::wabt::Result::Error; \ | | 58| 182| } \ | | 59| 1.40k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2263| 1.22k| CALLBACK(OnSegmentInfoCount, count); ------------------ | | 61| 1.22k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.22k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.22k| do { \ | | | | | | 42| 1.22k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.22k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.22k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.22k| #member " callback failed") ------------------ 2264| 1.58k| for (Index i = 0; i < count; i++) { ------------------ | Branch (2264:27): [True: 1.21k, False: 368] ------------------ 2265| 1.21k| std::string_view name; 2266| 1.21k| Address alignment_log2; 2267| 1.21k| uint32_t flags; 2268| 1.21k| CHECK_RESULT(ReadStr(&name, "segment name")); ------------------ | | 55| 1.21k| do { \ | | 56| 1.21k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 216, False: 996] | | ------------------ | | 57| 216| return ::wabt::Result::Error; \ | | 58| 216| } \ | | 59| 1.21k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2269| 996| CHECK_RESULT(ReadAlignment(&alignment_log2, "segment alignment")); ------------------ | | 55| 996| do { \ | | 56| 996| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 415, False: 581] | | ------------------ | | 57| 415| return ::wabt::Result::Error; \ | | 58| 415| } \ | | 59| 996| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2270| 581| CHECK_RESULT(ReadU32Leb128(&flags, "segment flags")); ------------------ | | 55| 581| do { \ | | 56| 581| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 223, False: 358] | | ------------------ | | 57| 223| return ::wabt::Result::Error; \ | | 58| 223| } \ | | 59| 581| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2271| 358| CALLBACK(OnSegmentInfo, i, name, alignment_log2, flags); ------------------ | | 61| 358| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 358|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 358| do { \ | | | | | | 42| 358| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 358] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 358| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 358| #member " callback failed") ------------------ 2272| 358| } 2273| 368| break; 2274| 1.04k| case LinkingEntryType::InitFunctions: ------------------ | Branch (2274:7): [True: 1.04k, False: 66.2k] ------------------ 2275| 1.04k| CHECK_RESULT(ReadU32Leb128(&count, "info count")); ------------------ | | 55| 1.04k| do { \ | | 56| 1.04k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 389, False: 659] | | ------------------ | | 57| 389| return ::wabt::Result::Error; \ | | 58| 389| } \ | | 59| 1.04k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2276| 659| CALLBACK(OnInitFunctionCount, count); ------------------ | | 61| 659| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 659|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 659| do { \ | | | | | | 42| 659| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 659] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 659| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 659| #member " callback failed") ------------------ 2277| 1.33k| while (count--) { ------------------ | Branch (2277:16): [True: 1.10k, False: 228] ------------------ 2278| 1.10k| uint32_t priority; 2279| 1.10k| uint32_t symbol; 2280| 1.10k| CHECK_RESULT(ReadU32Leb128(&priority, "priority")); ------------------ | | 55| 1.10k| do { \ | | 56| 1.10k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 163, False: 946] | | ------------------ | | 57| 163| return ::wabt::Result::Error; \ | | 58| 163| } \ | | 59| 1.10k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2281| 946| CHECK_RESULT(ReadU32Leb128(&symbol, "symbol index")); ------------------ | | 55| 946| do { \ | | 56| 946| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 268, False: 678] | | ------------------ | | 57| 268| return ::wabt::Result::Error; \ | | 58| 268| } \ | | 59| 946| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2282| 678| CALLBACK(OnInitFunction, priority, symbol); ------------------ | | 61| 678| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 678|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 678| do { \ | | | | | | 42| 678| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 678] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 678| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 678| #member " callback failed") ------------------ 2283| 678| } 2284| 228| break; 2285| 12.1k| case LinkingEntryType::ComdatInfo: ------------------ | Branch (2285:7): [True: 12.1k, False: 55.1k] ------------------ 2286| 12.1k| CHECK_RESULT(ReadU32Leb128(&count, "count")); ------------------ | | 55| 12.1k| do { \ | | 56| 12.1k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 37, False: 12.1k] | | ------------------ | | 57| 37| return ::wabt::Result::Error; \ | | 58| 37| } \ | | 59| 12.1k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2287| 12.1k| CALLBACK(OnComdatCount, count); ------------------ | | 61| 12.1k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 12.1k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 12.1k| do { \ | | | | | | 42| 12.1k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 12.1k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 12.1k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 12.1k| #member " callback failed") ------------------ 2288| 88.3k| while (count--) { ------------------ | Branch (2288:16): [True: 77.7k, False: 10.6k] ------------------ 2289| 77.7k| uint32_t flags; 2290| 77.7k| uint32_t entry_count; 2291| 77.7k| std::string_view name; 2292| 77.7k| CHECK_RESULT(ReadStr(&name, "comdat name")); ------------------ | | 55| 77.7k| do { \ | | 56| 77.7k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 368, False: 77.3k] | | ------------------ | | 57| 368| return ::wabt::Result::Error; \ | | 58| 368| } \ | | 59| 77.7k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2293| 77.3k| CHECK_RESULT(ReadU32Leb128(&flags, "flags")); ------------------ | | 55| 77.3k| do { \ | | 56| 77.3k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 548, False: 76.8k] | | ------------------ | | 57| 548| return ::wabt::Result::Error; \ | | 58| 548| } \ | | 59| 77.3k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2294| 76.8k| CHECK_RESULT(ReadU32Leb128(&entry_count, "entry count")); ------------------ | | 55| 76.8k| do { \ | | 56| 76.8k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 151, False: 76.6k] | | ------------------ | | 57| 151| return ::wabt::Result::Error; \ | | 58| 151| } \ | | 59| 76.8k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2295| 76.6k| CALLBACK(OnComdatBegin, name, flags, entry_count); ------------------ | | 61| 76.6k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 76.6k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 76.6k| do { \ | | | | | | 42| 76.6k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 76.6k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 76.6k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 76.6k| #member " callback failed") ------------------ 2296| 140k| while (entry_count--) { ------------------ | Branch (2296:18): [True: 64.2k, False: 76.2k] ------------------ 2297| 64.2k| uint32_t kind; 2298| 64.2k| uint32_t index; 2299| 64.2k| CHECK_RESULT(ReadU32Leb128(&kind, "kind")); ------------------ | | 55| 64.2k| do { \ | | 56| 64.2k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 189, False: 64.0k] | | ------------------ | | 57| 189| return ::wabt::Result::Error; \ | | 58| 189| } \ | | 59| 64.2k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2300| 64.0k| CHECK_RESULT(ReadU32Leb128(&index, "index")); ------------------ | | 55| 64.0k| do { \ | | 56| 64.0k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 187, False: 63.8k] | | ------------------ | | 57| 187| return ::wabt::Result::Error; \ | | 58| 187| } \ | | 59| 64.0k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2301| 63.8k| ComdatType comdat_type = static_cast(kind); 2302| 63.8k| CALLBACK(OnComdatEntry, comdat_type, index); ------------------ | | 61| 63.8k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 63.8k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 63.8k| do { \ | | | | | | 42| 63.8k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 63.8k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 63.8k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 63.8k| #member " callback failed") ------------------ 2303| 63.8k| } 2304| 76.6k| } 2305| 10.6k| break; 2306| 50.0k| default: ------------------ | Branch (2306:7): [True: 50.0k, False: 17.2k] ------------------ 2307| | // Unknown subsection, skip it. 2308| 50.0k| state_.offset = subsection_end; 2309| 50.0k| break; 2310| 67.2k| } 2311| 61.9k| ERROR_UNLESS(state_.offset == subsection_end, ------------------ | | 48| 61.9k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 61.9k| do { \ | | | | 42| 61.9k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 11.3k, False: 50.6k] | | | | ------------------ | | | | 43| 11.3k| PrintError(__VA_ARGS__); \ | | | | 44| 11.3k| return Result::Error; \ | | | | 45| 11.3k| } \ | | | | 46| 61.9k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2312| 61.9k| "unfinished sub-section (expected end: 0x%" PRIzx ")", 2313| 61.9k| subsection_end); 2314| 61.9k| } 2315| 477| CALLBACK0(EndLinkingSection); ------------------ | | 58| 477| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 477|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 477| do { \ | | | | | | 42| 477| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 477] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 477| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2316| 477| return Result::Ok; 2317| 477|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader13ReadAlignmentEPmPKc: 432| 6.75k|Result BinaryReader::ReadAlignment(Address* alignment_log2, const char* desc) { 433| 6.75k| uint32_t value; 434| 6.75k| CHECK_RESULT(ReadU32Leb128(&value, desc)); ------------------ | | 55| 6.75k| do { \ | | 56| 6.75k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 188, False: 6.57k] | | ------------------ | | 57| 188| return ::wabt::Result::Error; \ | | 58| 188| } \ | | 59| 6.75k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 435| 6.57k| if (value >= 128 || ------------------ | Branch (435:7): [True: 55, False: 6.51k] ------------------ 436| 6.57k| (value >= 32 && !options_.features.multi_memory_enabled())) { ------------------ | Branch (436:8): [True: 424, False: 6.09k] | Branch (436:23): [True: 185, False: 239] ------------------ 437| 240| PrintError("invalid %s: %u", desc, value); 438| 240| return Result::Error; 439| 240| } 440| 6.33k| *alignment_log2 = value; 441| 6.33k| return Result::Ok; 442| 6.57k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader23ReadCodeMetadataSectionENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEm: 2345| 3.49k| Offset section_size) { 2346| 3.49k| CALLBACK(BeginCodeMetadataSection, name, section_size); ------------------ | | 61| 3.49k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 3.49k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 3.49k| do { \ | | | | | | 42| 3.49k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 3.49k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 3.49k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 3.49k| #member " callback failed") ------------------ 2347| | 2348| 3.49k| Index num_functions; 2349| 3.49k| CHECK_RESULT(ReadCount(&num_functions, "function count")); ------------------ | | 55| 3.49k| do { \ | | 56| 3.49k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 394, False: 3.09k] | | ------------------ | | 57| 394| return ::wabt::Result::Error; \ | | 58| 394| } \ | | 59| 3.49k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2350| 3.09k| CALLBACK(OnCodeMetadataFuncCount, num_functions); ------------------ | | 61| 3.09k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 3.09k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 3.09k| do { \ | | | | | | 42| 3.09k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 3.09k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 3.09k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 3.09k| #member " callback failed") ------------------ 2351| | 2352| 3.09k| Index last_function_index = kInvalidIndex; 2353| 5.49k| for (Index i = 0; i < num_functions; ++i) { ------------------ | Branch (2353:21): [True: 5.23k, False: 267] ------------------ 2354| 5.23k| Index function_index; 2355| 5.23k| CHECK_RESULT(ReadCount(&function_index, "function index")); ------------------ | | 55| 5.23k| do { \ | | 56| 5.23k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 412, False: 4.82k] | | ------------------ | | 57| 412| return ::wabt::Result::Error; \ | | 58| 412| } \ | | 59| 5.23k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2356| 4.82k| ERROR_UNLESS(function_index >= num_func_imports_, ------------------ | | 48| 4.82k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 4.82k| do { \ | | | | 42| 4.82k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 215, False: 4.60k] | | | | ------------------ | | | | 43| 215| PrintError(__VA_ARGS__); \ | | | | 44| 215| return Result::Error; \ | | | | 45| 215| } \ | | | | 46| 4.82k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2357| 4.60k| "function import can't have metadata (got %" PRIindex ")", 2358| 4.60k| function_index); 2359| 4.60k| ERROR_UNLESS(function_index < NumTotalFuncs(), ------------------ | | 48| 4.60k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 4.60k| do { \ | | | | 42| 4.60k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 258, False: 4.34k] | | | | ------------------ | | | | 43| 258| PrintError(__VA_ARGS__); \ | | | | 44| 258| return Result::Error; \ | | | | 45| 258| } \ | | | | 46| 4.60k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2360| 4.34k| "invalid function index: %" PRIindex, function_index); 2361| 4.34k| ERROR_UNLESS(function_index != last_function_index, ------------------ | | 48| 4.34k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 4.34k| do { \ | | | | 42| 4.34k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 258, False: 4.08k] | | | | ------------------ | | | | 43| 258| PrintError(__VA_ARGS__); \ | | | | 44| 258| return Result::Error; \ | | | | 45| 258| } \ | | | | 46| 4.34k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2362| 4.08k| "duplicate function index: %" PRIindex, function_index); 2363| 4.08k| ERROR_UNLESS(last_function_index == kInvalidIndex || ------------------ | | 48| 4.08k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 4.08k| do { \ | | | | 42| 10.1k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 2.10k, False: 1.98k] | | | | | Branch (42:9): [True: 1.76k, False: 217] | | | | ------------------ | | | | 43| 217| PrintError(__VA_ARGS__); \ | | | | 44| 217| return Result::Error; \ | | | | 45| 217| } \ | | | | 46| 4.08k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2364| 3.87k| function_index > last_function_index, 2365| 3.87k| "function index out of order: %" PRIindex, function_index); 2366| 3.87k| last_function_index = function_index; 2367| | 2368| 3.87k| Index num_metadata; 2369| 3.87k| CHECK_RESULT(ReadCount(&num_metadata, "metadata instances count")); ------------------ | | 55| 3.87k| do { \ | | 56| 3.87k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 343, False: 3.52k] | | ------------------ | | 57| 343| return ::wabt::Result::Error; \ | | 58| 343| } \ | | 59| 3.87k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2370| | 2371| 3.52k| CALLBACK(OnCodeMetadataCount, function_index, num_metadata); ------------------ | | 61| 3.52k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 3.52k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 3.52k| do { \ | | | | | | 42| 3.52k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 3.52k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 3.52k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 3.52k| #member " callback failed") ------------------ 2372| | 2373| 3.52k| Offset last_code_offset = kInvalidOffset; 2374| 5.61k| for (Index j = 0; j < num_metadata; ++j) { ------------------ | Branch (2374:23): [True: 3.21k, False: 2.40k] ------------------ 2375| 3.21k| Offset code_offset; 2376| 3.21k| CHECK_RESULT(ReadOffset(&code_offset, "code offset")); ------------------ | | 55| 3.21k| do { \ | | 56| 3.21k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 178, False: 3.04k] | | ------------------ | | 57| 178| return ::wabt::Result::Error; \ | | 58| 178| } \ | | 59| 3.21k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2377| 3.04k| ERROR_UNLESS(code_offset != last_code_offset, ------------------ | | 48| 3.04k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 3.04k| do { \ | | | | 42| 3.04k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 170, False: 2.87k] | | | | ------------------ | | | | 43| 170| PrintError(__VA_ARGS__); \ | | | | 44| 170| return Result::Error; \ | | | | 45| 170| } \ | | | | 46| 3.04k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2378| 2.87k| "duplicate code offset: %" PRIzx, code_offset); 2379| 2.87k| ERROR_UNLESS( ------------------ | | 48| 2.87k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 2.87k| do { \ | | | | 42| 6.89k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 1.71k, False: 1.15k] | | | | | Branch (42:9): [True: 831, False: 324] | | | | ------------------ | | | | 43| 324| PrintError(__VA_ARGS__); \ | | | | 44| 324| return Result::Error; \ | | | | 45| 324| } \ | | | | 46| 2.87k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2380| 2.54k| last_code_offset == kInvalidOffset || code_offset > last_code_offset, 2381| 2.54k| "code offset out of order: %" PRIzx, code_offset); 2382| 2.54k| last_code_offset = code_offset; 2383| | 2384| 2.54k| Address data_size; 2385| 2.54k| const void* data; 2386| 2.54k| CHECK_RESULT(ReadBytes(&data, &data_size, "instance data")); ------------------ | | 55| 2.54k| do { \ | | 56| 2.54k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 456, False: 2.09k] | | ------------------ | | 57| 456| return ::wabt::Result::Error; \ | | 58| 456| } \ | | 59| 2.54k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2387| 2.09k| CALLBACK(OnCodeMetadata, code_offset, data, data_size); ------------------ | | 61| 2.09k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2.09k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.09k| do { \ | | | | | | 42| 2.09k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2.09k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2.09k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2.09k| #member " callback failed") ------------------ 2388| 2.09k| } 2389| 3.52k| } 2390| | 2391| 267| CALLBACK(EndCodeMetadataSection); ------------------ | | 61| 267| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 267|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 267| do { \ | | | | | | 42| 267| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 267] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 267| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 267| #member " callback failed") ------------------ 2392| 267| return Result::Ok; 2393| 267|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader9ReadBytesEPPKvPmPKc: 399| 2.56k| const char* desc) { 400| 2.56k| uint32_t data_size = 0; 401| 2.56k| CHECK_RESULT(ReadU32Leb128(&data_size, "data size")); ------------------ | | 55| 2.56k| do { \ | | 56| 2.56k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 327, False: 2.23k] | | ------------------ | | 57| 327| return ::wabt::Result::Error; \ | | 58| 327| } \ | | 59| 2.56k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 402| 2.23k| CHECK_RESULT(ReadBytesWithSize(out_data, data_size, desc)); ------------------ | | 55| 2.23k| do { \ | | 56| 2.23k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 129, False: 2.10k] | | ------------------ | | 57| 129| return ::wabt::Result::Error; \ | | 58| 129| } \ | | 59| 2.23k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 403| 2.10k| *out_data_size = data_size; 404| 2.10k| return Result::Ok; 405| 2.23k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ValueRestoreGuardIbXadL_ZNS1_23reading_custom_section_EEEED2Ev: 86| 106k| ~ValueRestoreGuard() { this_->*member = previous_value_; } binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader15ReadTypeSectionEm: 2437| 530|Result BinaryReader::ReadTypeSection(Offset section_size) { 2438| 530| CALLBACK(BeginTypeSection, section_size); ------------------ | | 61| 530| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 530|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 530| do { \ | | | | | | 42| 530| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 530] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 530| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 530| #member " callback failed") ------------------ 2439| 530| Index num_signatures; 2440| 530| CHECK_RESULT(ReadCount(&num_signatures, "type count")); ------------------ | | 55| 530| do { \ | | 56| 530| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 75, False: 455] | | ------------------ | | 57| 75| return ::wabt::Result::Error; \ | | 58| 75| } \ | | 59| 530| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2441| 455| CALLBACK(OnTypeCount, num_signatures); ------------------ | | 61| 455| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 455|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 455| do { \ | | | | | | 42| 455| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 455] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 455| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 455| #member " callback failed") ------------------ 2442| | 2443| 1.92k| for (Index i = 0; i < num_signatures; ++i) { ------------------ | Branch (2443:21): [True: 1.55k, False: 372] ------------------ 2444| 1.55k| Type form; 2445| 1.55k| if (options_.features.gc_enabled()) { ------------------ | Branch (2445:9): [True: 804, False: 753] ------------------ 2446| 804| CHECK_RESULT(ReadType(&form, "type form")); ------------------ | | 55| 804| do { \ | | 56| 804| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 802] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 804| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2447| 804| } else { 2448| 753| uint8_t type; 2449| 753| CHECK_RESULT(ReadU8(&type, "type form")); ------------------ | | 55| 753| do { \ | | 56| 753| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 11, False: 742] | | ------------------ | | 57| 11| return ::wabt::Result::Error; \ | | 58| 11| } \ | | 59| 753| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2450| 742| ERROR_UNLESS(type == 0x60, "unexpected type form (got %#x)", type); ------------------ | | 48| 742|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 742| do { \ | | | | 42| 742| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 24, False: 718] | | | | ------------------ | | | | 43| 24| PrintError(__VA_ARGS__); \ | | | | 44| 24| return Result::Error; \ | | | | 45| 24| } \ | | | | 46| 742| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2451| 718| form = Type::Func; 2452| 718| } 2453| | 2454| 1.52k| switch (form) { 2455| 1.50k| case Type::Func: { ------------------ | Branch (2455:7): [True: 1.50k, False: 18] ------------------ 2456| 1.50k| Index num_params; 2457| 1.50k| CHECK_RESULT(ReadCount(&num_params, "function param count")); ------------------ | | 55| 1.50k| do { \ | | 56| 1.50k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 8, False: 1.49k] | | ------------------ | | 57| 8| return ::wabt::Result::Error; \ | | 58| 8| } \ | | 59| 1.50k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2458| | 2459| 1.49k| param_types_.resize(num_params); 2460| | 2461| 2.95k| for (Index j = 0; j < num_params; ++j) { ------------------ | Branch (2461:27): [True: 1.46k, False: 1.48k] ------------------ 2462| 1.46k| Type param_type; 2463| 1.46k| CHECK_RESULT(ReadType(¶m_type, "function param type")); ------------------ | | 55| 1.46k| do { \ | | 56| 1.46k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.46k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.46k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2464| 1.46k| ERROR_UNLESS(IsConcreteType(param_type), ------------------ | | 48| 1.46k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 1.46k| do { \ | | | | 42| 1.46k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 7, False: 1.46k] | | | | ------------------ | | | | 43| 14| PrintError(__VA_ARGS__); \ | | | | ------------------ | | | | | Branch (43:18): [True: 0, False: 7] | | | | ------------------ | | | | 44| 7| return Result::Error; \ | | | | 45| 7| } \ | | | | 46| 1.46k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2465| 1.46k| "expected valid param type (got " PRItypecode ")", 2466| 1.46k| WABT_PRINTF_TYPE_CODE(param_type)); 2467| 1.46k| param_types_[j] = param_type; 2468| 1.46k| } 2469| | 2470| 1.48k| Index num_results; 2471| 1.48k| CHECK_RESULT(ReadCount(&num_results, "function result count")); ------------------ | | 55| 1.48k| do { \ | | 56| 1.48k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 6, False: 1.48k] | | ------------------ | | 57| 6| return ::wabt::Result::Error; \ | | 58| 6| } \ | | 59| 1.48k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2472| | 2473| 1.48k| result_types_.resize(num_results); 2474| | 2475| 2.33k| for (Index j = 0; j < num_results; ++j) { ------------------ | Branch (2475:27): [True: 868, False: 1.47k] ------------------ 2476| 868| Type result_type; 2477| 868| CHECK_RESULT(ReadType(&result_type, "function result type")); ------------------ | | 55| 868| do { \ | | 56| 868| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 9, False: 859] | | ------------------ | | 57| 9| return ::wabt::Result::Error; \ | | 58| 9| } \ | | 59| 868| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2478| 859| ERROR_UNLESS(IsConcreteType(result_type), ------------------ | | 48| 859|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 859| do { \ | | | | 42| 859| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 2, False: 857] | | | | ------------------ | | | | 43| 4| PrintError(__VA_ARGS__); \ | | | | ------------------ | | | | | Branch (43:18): [True: 1, False: 1] | | | | ------------------ | | | | 44| 2| return Result::Error; \ | | | | 45| 2| } \ | | | | 46| 859| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2479| 857| "expected valid result type (got " PRItypecode ")", 2480| 857| WABT_PRINTF_TYPE_CODE(result_type)); 2481| 857| result_types_[j] = result_type; 2482| 857| } 2483| | 2484| 1.47k| Type* param_types = num_params ? param_types_.data() : nullptr; ------------------ | Branch (2484:29): [True: 806, False: 664] ------------------ 2485| 1.47k| Type* result_types = num_results ? result_types_.data() : nullptr; ------------------ | Branch (2485:30): [True: 827, False: 643] ------------------ 2486| | 2487| 1.47k| CALLBACK(OnFuncType, i, num_params, param_types, num_results, ------------------ | | 61| 1.47k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.47k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.47k| do { \ | | | | | | 42| 1.47k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.47k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.47k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.47k| #member " callback failed") ------------------ 2488| 1.47k| result_types); 2489| 1.47k| break; 2490| 1.47k| } 2491| | 2492| 1.47k| case Type::Struct: { ------------------ | Branch (2492:7): [True: 6, False: 1.51k] ------------------ 2493| 6| ERROR_UNLESS(options_.features.gc_enabled(), ------------------ | | 48| 6|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 6| do { \ | | | | 42| 6| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 6] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 6| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2494| 6| "invalid type form: struct not allowed"); 2495| 6| Index num_fields; 2496| 6| CHECK_RESULT(ReadCount(&num_fields, "field count")); ------------------ | | 55| 6| do { \ | | 56| 6| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 4] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 6| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2497| | 2498| 4| fields_.resize(num_fields); 2499| 8| for (Index j = 0; j < num_fields; ++j) { ------------------ | Branch (2499:27): [True: 4, False: 4] ------------------ 2500| 4| CHECK_RESULT(ReadField(&fields_[j])); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2501| 4| } 2502| | 2503| 4| CALLBACK(OnStructType, i, fields_.size(), fields_.data()); ------------------ | | 61| 4| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 4|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 4| do { \ | | | | | | 42| 4| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 4| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 4| #member " callback failed") ------------------ 2504| 4| break; 2505| 4| } 2506| | 2507| 4| case Type::Array: { ------------------ | Branch (2507:7): [True: 0, False: 1.52k] ------------------ 2508| 0| ERROR_UNLESS(options_.features.gc_enabled(), ------------------ | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 0| do { \ | | | | 42| 0| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 0| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2509| 0| "invalid type form: array not allowed"); 2510| | 2511| 0| TypeMut field; 2512| 0| CHECK_RESULT(ReadField(&field)); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2513| 0| CALLBACK(OnArrayType, i, field); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 2514| 0| break; 2515| 0| }; 2516| | 2517| 12| default: ------------------ | Branch (2517:7): [True: 12, False: 1.50k] ------------------ 2518| 12| PrintError("unexpected type form (got " PRItypecode ")", 2519| 12| WABT_PRINTF_TYPE_CODE(form)); ------------------ | | 32| 12| (static_cast(x) < 0 ? "-" : ""), std::abs(static_cast(x)) | | ------------------ | | | Branch (32:4): [True: 2, False: 10] | | ------------------ ------------------ 2520| 12| return Result::Error; 2521| 1.52k| } 2522| 1.52k| } 2523| 372| CALLBACK0(EndTypeSection); ------------------ | | 58| 372| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 372|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 372| do { \ | | | | | | 42| 372| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 372] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 372| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2524| 372| return Result::Ok; 2525| 372|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader8ReadTypeEPNS_4TypeEPKc: 350| 6.56k|Result BinaryReader::ReadType(Type* out_value, const char* desc) { 351| 6.56k| uint32_t type = 0; 352| 6.56k| CHECK_RESULT(ReadS32Leb128(&type, desc)); ------------------ | | 55| 6.56k| do { \ | | 56| 6.56k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 13, False: 6.54k] | | ------------------ | | 57| 13| return ::wabt::Result::Error; \ | | 58| 13| } \ | | 59| 6.56k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 353| 6.54k| if (static_cast(type) == Type::Reference) { ------------------ | Branch (353:7): [True: 4, False: 6.54k] ------------------ 354| 4| uint32_t heap_type = 0; 355| 4| CHECK_RESULT(ReadS32Leb128(&heap_type, desc)); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 356| 4| *out_value = Type(Type::Reference, heap_type); 357| 6.54k| } else { 358| 6.54k| *out_value = static_cast(type); 359| 6.54k| } 360| 6.54k| return Result::Ok; 361| 6.54k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader14IsConcreteTypeENS_4TypeE: 528| 5.74k|bool BinaryReader::IsConcreteType(Type type) { 529| 5.74k| switch (type) { 530| 1.63k| case Type::I32: ------------------ | Branch (530:5): [True: 1.63k, False: 4.11k] ------------------ 531| 2.04k| case Type::I64: ------------------ | Branch (531:5): [True: 408, False: 5.33k] ------------------ 532| 2.25k| case Type::F32: ------------------ | Branch (532:5): [True: 213, False: 5.53k] ------------------ 533| 2.53k| case Type::F64: ------------------ | Branch (533:5): [True: 274, False: 5.47k] ------------------ 534| 2.53k| return true; 535| | 536| 372| case Type::V128: ------------------ | Branch (536:5): [True: 372, False: 5.37k] ------------------ 537| 372| return options_.features.simd_enabled(); 538| | 539| 54| case Type::FuncRef: ------------------ | Branch (539:5): [True: 54, False: 5.69k] ------------------ 540| 233| case Type::ExternRef: ------------------ | Branch (540:5): [True: 179, False: 5.56k] ------------------ 541| 233| return options_.features.reference_types_enabled(); 542| | 543| 4| case Type::Reference: ------------------ | Branch (543:5): [True: 4, False: 5.74k] ------------------ 544| 4| return options_.features.function_references_enabled(); 545| | 546| 2.60k| default: ------------------ | Branch (546:5): [True: 2.60k, False: 3.13k] ------------------ 547| 2.60k| return false; 548| 5.74k| } 549| 5.74k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader9ReadFieldEPNS_7TypeMutE: 512| 4|Result BinaryReader::ReadField(TypeMut* out_value) { 513| | // TODO: Reuse for global header too? 514| 4| Type field_type; 515| 4| CHECK_RESULT(ReadType(&field_type, "field type")); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 516| 4| ERROR_UNLESS(IsConcreteType(field_type), ------------------ | | 48| 4|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 4| do { \ | | | | 42| 4| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 4] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | ------------------ | | | | | Branch (43:18): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 4| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 517| 4| "expected valid field type (got " PRItypecode ")", 518| 4| WABT_PRINTF_TYPE_CODE(field_type)); 519| | 520| 4| uint8_t mutable_ = 0; 521| 4| CHECK_RESULT(ReadU8(&mutable_, "field mutability")); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 522| 4| ERROR_UNLESS(mutable_ <= 1, "field mutability must be 0 or 1"); ------------------ | | 48| 4|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 4| do { \ | | | | 42| 4| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 4] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 4| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 523| 4| out_value->type = field_type; 524| 4| out_value->mutable_ = mutable_; 525| 4| return Result::Ok; 526| 4|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ReadImportSectionEm: 2527| 59|Result BinaryReader::ReadImportSection(Offset section_size) { 2528| 59| CALLBACK(BeginImportSection, section_size); ------------------ | | 61| 59| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 59|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 59| do { \ | | | | | | 42| 59| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 59] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 59| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 59| #member " callback failed") ------------------ 2529| 59| Index num_imports; 2530| 59| CHECK_RESULT(ReadCount(&num_imports, "import count")); ------------------ | | 55| 59| do { \ | | 56| 59| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 16, False: 43] | | ------------------ | | 57| 16| return ::wabt::Result::Error; \ | | 58| 16| } \ | | 59| 59| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2531| 43| CALLBACK(OnImportCount, num_imports); ------------------ | | 61| 43| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 43|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 43| do { \ | | | | | | 42| 43| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 43] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 43| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 43| #member " callback failed") ------------------ 2532| 1.60k| for (Index i = 0; i < num_imports; ++i) { ------------------ | Branch (2532:21): [True: 1.58k, False: 12] ------------------ 2533| 1.58k| std::string_view module_name; 2534| 1.58k| CHECK_RESULT(ReadStr(&module_name, "import module name")); ------------------ | | 55| 1.58k| do { \ | | 56| 1.58k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 12, False: 1.57k] | | ------------------ | | 57| 12| return ::wabt::Result::Error; \ | | 58| 12| } \ | | 59| 1.58k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2535| 1.57k| std::string_view field_name; 2536| 1.57k| CHECK_RESULT(ReadStr(&field_name, "import field name")); ------------------ | | 55| 1.57k| do { \ | | 56| 1.57k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 3, False: 1.57k] | | ------------------ | | 57| 3| return ::wabt::Result::Error; \ | | 58| 3| } \ | | 59| 1.57k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2537| | 2538| 1.57k| uint8_t kind; 2539| 1.57k| CHECK_RESULT(ReadU8(&kind, "import kind")); ------------------ | | 55| 1.57k| do { \ | | 56| 1.57k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.57k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.57k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2540| 1.57k| CALLBACK(OnImport, i, static_cast(kind), module_name, ------------------ | | 61| 1.57k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.57k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.57k| do { \ | | | | | | 42| 1.57k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.57k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.57k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.57k| #member " callback failed") ------------------ 2541| 1.57k| field_name); 2542| 1.57k| switch (static_cast(kind)) { 2543| 1.54k| case ExternalKind::Func: { ------------------ | Branch (2543:7): [True: 1.54k, False: 33] ------------------ 2544| 1.54k| Index sig_index; 2545| 1.54k| CHECK_RESULT(ReadIndex(&sig_index, "import signature index")); ------------------ | | 55| 1.54k| do { \ | | 56| 1.54k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.54k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.54k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2546| 1.54k| CALLBACK(OnImportFunc, i, module_name, field_name, num_func_imports_, ------------------ | | 61| 1.54k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.54k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.54k| do { \ | | | | | | 42| 1.54k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 6, False: 1.53k] | | | | | | ------------------ | | | | | | 43| 6| PrintError(__VA_ARGS__); \ | | | | | | 44| 6| return Result::Error; \ | | | | | | 45| 6| } \ | | | | | | 46| 1.54k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.54k| #member " callback failed") ------------------ 2547| 1.53k| sig_index); 2548| 1.53k| num_func_imports_++; 2549| 1.53k| break; 2550| 1.54k| } 2551| | 2552| 0| case ExternalKind::Table: { ------------------ | Branch (2552:7): [True: 0, False: 1.57k] ------------------ 2553| 0| Type elem_type; 2554| 0| Limits elem_limits; 2555| 0| CHECK_RESULT(ReadTable(&elem_type, &elem_limits)); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2556| 0| CALLBACK(OnImportTable, i, module_name, field_name, num_table_imports_, ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 2557| 0| elem_type, &elem_limits); 2558| 0| num_table_imports_++; 2559| 0| break; 2560| 0| } 2561| | 2562| 0| case ExternalKind::Memory: { ------------------ | Branch (2562:7): [True: 0, False: 1.57k] ------------------ 2563| 0| Limits page_limits; 2564| 0| CHECK_RESULT(ReadMemory(&page_limits)); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2565| 0| CALLBACK(OnImportMemory, i, module_name, field_name, ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 2566| 0| num_memory_imports_, &page_limits); 2567| 0| num_memory_imports_++; 2568| 0| break; 2569| 0| } 2570| | 2571| 22| case ExternalKind::Global: { ------------------ | Branch (2571:7): [True: 22, False: 1.55k] ------------------ 2572| 22| Type type; 2573| 22| bool mutable_; 2574| 22| CHECK_RESULT(ReadGlobalHeader(&type, &mutable_)); ------------------ | | 55| 22| do { \ | | 56| 22| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 20] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 22| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2575| 20| CALLBACK(OnImportGlobal, i, module_name, field_name, ------------------ | | 61| 20| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 20|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 20| do { \ | | | | | | 42| 20| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 20] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 20| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 20| #member " callback failed") ------------------ 2576| 20| num_global_imports_, type, mutable_); 2577| 20| num_global_imports_++; 2578| 20| break; 2579| 20| } 2580| | 2581| 3| case ExternalKind::Tag: { ------------------ | Branch (2581:7): [True: 3, False: 1.57k] ------------------ 2582| 3| ERROR_UNLESS(options_.features.exceptions_enabled(), ------------------ | | 48| 3|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 3| do { \ | | | | 42| 3| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 3] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 3| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2583| 3| "invalid import tag kind: exceptions not allowed"); 2584| 3| Index sig_index; 2585| 3| CHECK_RESULT(ReadTagType(&sig_index)); ------------------ | | 55| 3| do { \ | | 56| 3| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 3] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 3| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2586| 3| CALLBACK(OnImportTag, i, module_name, field_name, num_tag_imports_, ------------------ | | 61| 3| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 3|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 3| do { \ | | | | | | 42| 3| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 3] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 3| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 3| #member " callback failed") ------------------ 2587| 3| sig_index); 2588| 3| num_tag_imports_++; 2589| 3| break; 2590| 3| } 2591| | 2592| 8| default: ------------------ | Branch (2592:7): [True: 8, False: 1.56k] ------------------ 2593| 8| PrintError("malformed import kind: %d", kind); 2594| 8| return Result::Error; 2595| 1.57k| } 2596| 1.57k| } 2597| | 2598| 12| CALLBACK0(EndImportSection); ------------------ | | 58| 12| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 12|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 12| do { \ | | | | | | 42| 12| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 12] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 12| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2599| 12| return Result::Ok; 2600| 12|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader9ReadTableEPNS_4TypeEPNS_6LimitsE: 573| 159|Result BinaryReader::ReadTable(Type* out_elem_type, Limits* out_elem_limits) { 574| 159| CHECK_RESULT(ReadRefType(out_elem_type, "table elem type")); ------------------ | | 55| 159| do { \ | | 56| 159| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 9, False: 150] | | ------------------ | | 57| 9| return ::wabt::Result::Error; \ | | 58| 9| } \ | | 59| 159| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 575| | 576| 150| uint8_t flags; 577| 150| uint32_t initial; 578| 150| uint32_t max = 0; 579| 150| CHECK_RESULT(ReadU8(&flags, "table flags")); ------------------ | | 55| 150| do { \ | | 56| 150| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 150] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 150| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 580| 150| bool has_max = flags & WABT_BINARY_LIMITS_HAS_MAX_FLAG; ------------------ | | 24| 150|#define WABT_BINARY_LIMITS_HAS_MAX_FLAG 0x1 ------------------ 581| 150| bool is_shared = flags & WABT_BINARY_LIMITS_IS_SHARED_FLAG; ------------------ | | 25| 150|#define WABT_BINARY_LIMITS_IS_SHARED_FLAG 0x2 ------------------ 582| 150| bool is_64 = flags & WABT_BINARY_LIMITS_IS_64_FLAG; ------------------ | | 26| 150|#define WABT_BINARY_LIMITS_IS_64_FLAG 0x4 ------------------ 583| 150| const uint8_t unknown_flags = flags & ~WABT_BINARY_LIMITS_ALL_FLAGS; ------------------ | | 28| 150| (WABT_BINARY_LIMITS_HAS_MAX_FLAG | WABT_BINARY_LIMITS_IS_SHARED_FLAG | \ | | ------------------ | | | | 24| 150|#define WABT_BINARY_LIMITS_HAS_MAX_FLAG 0x1 | | ------------------ | | (WABT_BINARY_LIMITS_HAS_MAX_FLAG | WABT_BINARY_LIMITS_IS_SHARED_FLAG | \ | | ------------------ | | | | 25| 150|#define WABT_BINARY_LIMITS_IS_SHARED_FLAG 0x2 | | ------------------ | | 29| 150| WABT_BINARY_LIMITS_IS_64_FLAG) | | ------------------ | | | | 26| 150|#define WABT_BINARY_LIMITS_IS_64_FLAG 0x4 | | ------------------ ------------------ 584| 150| ERROR_IF(is_shared, "tables may not be shared"); ------------------ | | 41| 150| do { \ | | 42| 150| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 3, False: 147] | | ------------------ | | 43| 3| PrintError(__VA_ARGS__); \ | | 44| 3| return Result::Error; \ | | 45| 3| } \ | | 46| 150| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 585| 147| ERROR_IF(is_64 && !options_.features.memory64_enabled(), ------------------ | | 41| 147| do { \ | | 42| 294| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 0, False: 147] | | | Branch (42:9): [True: 0, False: 0] | | ------------------ | | 43| 0| PrintError(__VA_ARGS__); \ | | 44| 0| return Result::Error; \ | | 45| 0| } \ | | 46| 147| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 586| 147| "memory64 not allowed"); 587| 147| ERROR_UNLESS(unknown_flags == 0, "malformed table limits flag: %d", flags); ------------------ | | 48| 147|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 147| do { \ | | | | 42| 147| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 147] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 147| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 588| 147| CHECK_RESULT(ReadU32Leb128(&initial, "table initial elem count")); ------------------ | | 55| 147| do { \ | | 56| 147| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 147] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 147| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 589| 147| if (has_max) { ------------------ | Branch (589:7): [True: 53, False: 94] ------------------ 590| 53| CHECK_RESULT(ReadU32Leb128(&max, "table max elem count")); ------------------ | | 55| 53| do { \ | | 56| 53| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 52] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 53| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 591| 53| } 592| | 593| 146| out_elem_limits->has_max = has_max; 594| 146| out_elem_limits->is_64 = is_64; 595| 146| out_elem_limits->initial = initial; 596| 146| out_elem_limits->max = max; 597| 146| return Result::Ok; 598| 147|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader11ReadRefTypeEPNS_4TypeEPKc: 363| 191|Result BinaryReader::ReadRefType(Type* out_value, const char* desc) { 364| 191| uint32_t type = 0; 365| 191| CHECK_RESULT(ReadS32Leb128(&type, desc)); ------------------ | | 55| 191| do { \ | | 56| 191| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 191] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 191| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 366| 191| *out_value = static_cast(type); 367| 191| ERROR_UNLESS(out_value->IsRef(), "%s must be a reference type", desc); ------------------ | | 48| 191|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 191| do { \ | | | | 42| 191| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 13, False: 178] | | | | ------------------ | | | | 43| 13| PrintError(__VA_ARGS__); \ | | | | 44| 13| return Result::Error; \ | | | | 45| 13| } \ | | | | 46| 191| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 368| 178| return Result::Ok; 369| 191|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader10ReadMemoryEPNS_6LimitsE: 600| 354|Result BinaryReader::ReadMemory(Limits* out_page_limits) { 601| 354| uint8_t flags; 602| 354| uint64_t initial; 603| 354| uint64_t max = 0; 604| 354| CHECK_RESULT(ReadU8(&flags, "memory flags")); ------------------ | | 55| 354| do { \ | | 56| 354| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 3, False: 351] | | ------------------ | | 57| 3| return ::wabt::Result::Error; \ | | 58| 3| } \ | | 59| 354| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 605| 351| bool has_max = flags & WABT_BINARY_LIMITS_HAS_MAX_FLAG; ------------------ | | 24| 351|#define WABT_BINARY_LIMITS_HAS_MAX_FLAG 0x1 ------------------ 606| 351| bool is_shared = flags & WABT_BINARY_LIMITS_IS_SHARED_FLAG; ------------------ | | 25| 351|#define WABT_BINARY_LIMITS_IS_SHARED_FLAG 0x2 ------------------ 607| 351| bool is_64 = flags & WABT_BINARY_LIMITS_IS_64_FLAG; ------------------ | | 26| 351|#define WABT_BINARY_LIMITS_IS_64_FLAG 0x4 ------------------ 608| 351| const uint8_t unknown_flags = flags & ~WABT_BINARY_LIMITS_ALL_FLAGS; ------------------ | | 28| 351| (WABT_BINARY_LIMITS_HAS_MAX_FLAG | WABT_BINARY_LIMITS_IS_SHARED_FLAG | \ | | ------------------ | | | | 24| 351|#define WABT_BINARY_LIMITS_HAS_MAX_FLAG 0x1 | | ------------------ | | (WABT_BINARY_LIMITS_HAS_MAX_FLAG | WABT_BINARY_LIMITS_IS_SHARED_FLAG | \ | | ------------------ | | | | 25| 351|#define WABT_BINARY_LIMITS_IS_SHARED_FLAG 0x2 | | ------------------ | | 29| 351| WABT_BINARY_LIMITS_IS_64_FLAG) | | ------------------ | | | | 26| 351|#define WABT_BINARY_LIMITS_IS_64_FLAG 0x4 | | ------------------ ------------------ 609| 351| ERROR_UNLESS(unknown_flags == 0, "malformed memory limits flag: %d", flags); ------------------ | | 48| 351|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 351| do { \ | | | | 42| 351| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 7, False: 344] | | | | ------------------ | | | | 43| 7| PrintError(__VA_ARGS__); \ | | | | 44| 7| return Result::Error; \ | | | | 45| 7| } \ | | | | 46| 351| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 610| 344| ERROR_IF(is_shared && !options_.features.threads_enabled(), ------------------ | | 41| 344| do { \ | | 42| 690| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 2, False: 342] | | | Branch (42:9): [True: 0, False: 2] | | ------------------ | | 43| 0| PrintError(__VA_ARGS__); \ | | 44| 0| return Result::Error; \ | | 45| 0| } \ | | 46| 344| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 611| 344| "memory may not be shared: threads not allowed"); 612| 344| ERROR_IF(is_64 && !options_.features.memory64_enabled(), ------------------ | | 41| 344| do { \ | | 42| 725| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 37, False: 307] | | | Branch (42:9): [True: 0, False: 37] | | ------------------ | | 43| 0| PrintError(__VA_ARGS__); \ | | 44| 0| return Result::Error; \ | | 45| 0| } \ | | 46| 344| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 613| 344| "memory64 not allowed"); 614| 344| if (options_.features.memory64_enabled()) { ------------------ | Branch (614:7): [True: 209, False: 135] ------------------ 615| 209| CHECK_RESULT(ReadU64Leb128(&initial, "memory initial page count")); ------------------ | | 55| 209| do { \ | | 56| 209| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 208] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 209| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 616| 208| if (has_max) { ------------------ | Branch (616:9): [True: 91, False: 117] ------------------ 617| 91| CHECK_RESULT(ReadU64Leb128(&max, "memory max page count")); ------------------ | | 55| 91| do { \ | | 56| 91| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 91] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 91| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 618| 91| } 619| 208| } else { 620| 135| uint32_t initial32; 621| 135| CHECK_RESULT(ReadU32Leb128(&initial32, "memory initial page count")); ------------------ | | 55| 135| do { \ | | 56| 135| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 135] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 135| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 622| 135| initial = initial32; 623| 135| if (has_max) { ------------------ | Branch (623:9): [True: 67, False: 68] ------------------ 624| 67| uint32_t max32; 625| 67| CHECK_RESULT(ReadU32Leb128(&max32, "memory max page count")); ------------------ | | 55| 67| do { \ | | 56| 67| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 67] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 67| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 626| 67| max = max32; 627| 67| } 628| 135| } 629| | 630| 343| out_page_limits->has_max = has_max; 631| 343| out_page_limits->is_shared = is_shared; 632| 343| out_page_limits->is_64 = is_64; 633| 343| out_page_limits->initial = initial; 634| 343| out_page_limits->max = max; 635| | 636| 343| return Result::Ok; 637| 344|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader13ReadU64Leb128EPmPKc: 323| 3.58k|Result BinaryReader::ReadU64Leb128(uint64_t* out_value, const char* desc) { 324| 3.58k| const uint8_t* p = state_.data + state_.offset; 325| 3.58k| const uint8_t* end = state_.data + read_end_; 326| 3.58k| size_t bytes_read = wabt::ReadU64Leb128(p, end, out_value); 327| 3.58k| ERROR_UNLESS(bytes_read > 0, "unable to read u64 leb128: %s", desc); ------------------ | | 48| 3.58k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 3.58k| do { \ | | | | 42| 3.58k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 1, False: 3.58k] | | | | ------------------ | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | 44| 1| return Result::Error; \ | | | | 45| 1| } \ | | | | 46| 3.58k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 328| 3.58k| state_.offset += bytes_read; 329| 3.58k| return Result::Ok; 330| 3.58k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader16ReadGlobalHeaderEPNS_4TypeEPb: 639| 252|Result BinaryReader::ReadGlobalHeader(Type* out_type, bool* out_mutable) { 640| 252| Type global_type = Type::Void; 641| 252| uint8_t mutable_ = 0; 642| 252| CHECK_RESULT(ReadType(&global_type, "global type")); ------------------ | | 55| 252| do { \ | | 56| 252| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 252] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 252| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 643| 252| ERROR_UNLESS(IsConcreteType(global_type), "invalid global type: %#x", ------------------ | | 48| 252|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 252| do { \ | | | | 42| 252| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 8, False: 244] | | | | ------------------ | | | | 43| 8| PrintError(__VA_ARGS__); \ | | | | 44| 8| return Result::Error; \ | | | | 45| 8| } \ | | | | 46| 252| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 644| 244| static_cast(global_type)); 645| | 646| 244| CHECK_RESULT(ReadU8(&mutable_, "global mutability")); ------------------ | | 55| 244| do { \ | | 56| 244| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 244] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 244| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 647| 244| ERROR_UNLESS(mutable_ <= 1, "global mutability must be 0 or 1"); ------------------ | | 48| 244|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 244| do { \ | | | | 42| 244| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 2, False: 242] | | | | ------------------ | | | | 43| 2| PrintError(__VA_ARGS__); \ | | | | 44| 2| return Result::Error; \ | | | | 45| 2| } \ | | | | 46| 244| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 648| | 649| 242| *out_type = global_type; 650| 242| *out_mutable = mutable_; 651| 242| return Result::Ok; 652| 244|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader11ReadTagTypeEPj: 2319| 11|Result BinaryReader::ReadTagType(Index* out_sig_index) { 2320| 11| uint8_t attribute; 2321| 11| CHECK_RESULT(ReadU8(&attribute, "tag attribute")); ------------------ | | 55| 11| do { \ | | 56| 11| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 11] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 11| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2322| 11| ERROR_UNLESS(attribute == 0, "tag attribute must be 0"); ------------------ | | 48| 11|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 11| do { \ | | | | 42| 11| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 4, False: 7] | | | | ------------------ | | | | 43| 4| PrintError(__VA_ARGS__); \ | | | | 44| 4| return Result::Error; \ | | | | 45| 4| } \ | | | | 46| 11| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2323| 7| CHECK_RESULT(ReadIndex(out_sig_index, "tag signature index")); ------------------ | | 55| 7| do { \ | | 56| 7| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 7] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 7| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2324| 7| return Result::Ok; 2325| 7|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader19ReadFunctionSectionEm: 2602| 470|Result BinaryReader::ReadFunctionSection(Offset section_size) { 2603| 470| CALLBACK(BeginFunctionSection, section_size); ------------------ | | 61| 470| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 470|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 470| do { \ | | | | | | 42| 470| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 470] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 470| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 470| #member " callback failed") ------------------ 2604| 470| CHECK_RESULT( ------------------ | | 55| 470| do { \ | | 56| 470| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 37, False: 433] | | ------------------ | | 57| 37| return ::wabt::Result::Error; \ | | 58| 37| } \ | | 59| 470| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2605| 470| ReadCount(&num_function_signatures_, "function signature count")); 2606| 433| CALLBACK(OnFunctionCount, num_function_signatures_); ------------------ | | 61| 433| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 433|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 433| do { \ | | | | | | 42| 433| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 433] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 433| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 433| #member " callback failed") ------------------ 2607| 7.92k| for (Index i = 0; i < num_function_signatures_; ++i) { ------------------ | Branch (2607:21): [True: 7.54k, False: 374] ------------------ 2608| 7.54k| Index func_index = num_func_imports_ + i; 2609| 7.54k| Index sig_index; 2610| 7.54k| CHECK_RESULT(ReadIndex(&sig_index, "function signature index")); ------------------ | | 55| 7.54k| do { \ | | 56| 7.54k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 7, False: 7.54k] | | ------------------ | | 57| 7| return ::wabt::Result::Error; \ | | 58| 7| } \ | | 59| 7.54k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2611| 7.54k| CALLBACK(OnFunction, func_index, sig_index); ------------------ | | 61| 7.54k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 7.54k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 7.54k| do { \ | | | | | | 42| 7.54k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 52, False: 7.48k] | | | | | | ------------------ | | | | | | 43| 52| PrintError(__VA_ARGS__); \ | | | | | | 44| 52| return Result::Error; \ | | | | | | 45| 52| } \ | | | | | | 46| 7.54k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 7.54k| #member " callback failed") ------------------ 2612| 7.54k| } 2613| 374| CALLBACK0(EndFunctionSection); ------------------ | | 58| 374| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 374|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 374| do { \ | | | | | | 42| 374| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 374] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 374| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2614| 374| return Result::Ok; 2615| 374|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader16ReadTableSectionEm: 2617| 175|Result BinaryReader::ReadTableSection(Offset section_size) { 2618| 175| CALLBACK(BeginTableSection, section_size); ------------------ | | 61| 175| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 175|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 175| do { \ | | | | | | 42| 175| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 175] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 175| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 175| #member " callback failed") ------------------ 2619| 175| Index num_tables; 2620| 175| CHECK_RESULT(ReadCount(&num_tables, "table count")); ------------------ | | 55| 175| do { \ | | 56| 175| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 28, False: 147] | | ------------------ | | 57| 28| return ::wabt::Result::Error; \ | | 58| 28| } \ | | 59| 175| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2621| 147| CALLBACK(OnTableCount, num_tables); ------------------ | | 61| 147| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 147|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 147| do { \ | | | | | | 42| 147| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 147] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 147| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 147| #member " callback failed") ------------------ 2622| 293| for (Index i = 0; i < num_tables; ++i) { ------------------ | Branch (2622:21): [True: 159, False: 134] ------------------ 2623| 159| Index table_index = num_table_imports_ + i; 2624| 159| Type elem_type; 2625| 159| Limits elem_limits; 2626| 159| CHECK_RESULT(ReadTable(&elem_type, &elem_limits)); ------------------ | | 55| 159| do { \ | | 56| 159| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 13, False: 146] | | ------------------ | | 57| 13| return ::wabt::Result::Error; \ | | 58| 13| } \ | | 59| 159| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2627| 146| CALLBACK(OnTable, table_index, elem_type, &elem_limits); ------------------ | | 61| 146| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 146|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 146| do { \ | | | | | | 42| 146| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 146] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 146| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 146| #member " callback failed") ------------------ 2628| 146| } 2629| 134| CALLBACK0(EndTableSection); ------------------ | | 58| 134| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 134|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 134| do { \ | | | | | | 42| 134| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 134] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 134| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2630| 134| return Result::Ok; 2631| 134|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ReadMemorySectionEm: 2633| 277|Result BinaryReader::ReadMemorySection(Offset section_size) { 2634| 277| CALLBACK(BeginMemorySection, section_size); ------------------ | | 61| 277| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 277|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 277| do { \ | | | | | | 42| 277| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 277] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 277| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 277| #member " callback failed") ------------------ 2635| 277| Index num_memories; 2636| 277| CHECK_RESULT(ReadCount(&num_memories, "memory count")); ------------------ | | 55| 277| do { \ | | 56| 277| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 7, False: 270] | | ------------------ | | 57| 7| return ::wabt::Result::Error; \ | | 58| 7| } \ | | 59| 277| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2637| 270| CALLBACK(OnMemoryCount, num_memories); ------------------ | | 61| 270| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 270|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 270| do { \ | | | | | | 42| 270| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 270] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 270| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 270| #member " callback failed") ------------------ 2638| 610| for (Index i = 0; i < num_memories; ++i) { ------------------ | Branch (2638:21): [True: 354, False: 256] ------------------ 2639| 354| Index memory_index = num_memory_imports_ + i; 2640| 354| Limits page_limits; 2641| 354| CHECK_RESULT(ReadMemory(&page_limits)); ------------------ | | 55| 354| do { \ | | 56| 354| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 11, False: 343] | | ------------------ | | 57| 11| return ::wabt::Result::Error; \ | | 58| 11| } \ | | 59| 354| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2642| 343| CALLBACK(OnMemory, memory_index, &page_limits); ------------------ | | 61| 343| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 343|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 343| do { \ | | | | | | 42| 343| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 3, False: 340] | | | | | | ------------------ | | | | | | 43| 3| PrintError(__VA_ARGS__); \ | | | | | | 44| 3| return Result::Error; \ | | | | | | 45| 3| } \ | | | | | | 46| 343| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 343| #member " callback failed") ------------------ 2643| 343| } 2644| 256| CALLBACK0(EndMemorySection); ------------------ | | 58| 256| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 256|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 256| do { \ | | | | | | 42| 256| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 256] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 256| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2645| 256| return Result::Ok; 2646| 256|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ReadGlobalSectionEm: 2648| 84|Result BinaryReader::ReadGlobalSection(Offset section_size) { 2649| 84| CALLBACK(BeginGlobalSection, section_size); ------------------ | | 61| 84| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 84|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 84| do { \ | | | | | | 42| 84| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 84] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 84| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 84| #member " callback failed") ------------------ 2650| 84| Index num_globals; 2651| 84| CHECK_RESULT(ReadCount(&num_globals, "global count")); ------------------ | | 55| 84| do { \ | | 56| 84| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 13, False: 71] | | ------------------ | | 57| 13| return ::wabt::Result::Error; \ | | 58| 13| } \ | | 59| 84| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2652| 71| CALLBACK(OnGlobalCount, num_globals); ------------------ | | 61| 71| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 71|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 71| do { \ | | | | | | 42| 71| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 71] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 71| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 71| #member " callback failed") ------------------ 2653| 260| for (Index i = 0; i < num_globals; ++i) { ------------------ | Branch (2653:21): [True: 230, False: 30] ------------------ 2654| 230| Index global_index = num_global_imports_ + i; 2655| 230| Type global_type; 2656| 230| bool mutable_; 2657| 230| CHECK_RESULT(ReadGlobalHeader(&global_type, &mutable_)); ------------------ | | 55| 230| do { \ | | 56| 230| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 8, False: 222] | | ------------------ | | 57| 8| return ::wabt::Result::Error; \ | | 58| 8| } \ | | 59| 230| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2658| 222| CALLBACK(BeginGlobal, global_index, global_type, mutable_); ------------------ | | 61| 222| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 222|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 222| do { \ | | | | | | 42| 222| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 222] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 222| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 222| #member " callback failed") ------------------ 2659| 222| CALLBACK(BeginGlobalInitExpr, global_index); ------------------ | | 61| 222| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 222|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 222| do { \ | | | | | | 42| 222| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 222] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 222| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 222| #member " callback failed") ------------------ 2660| 222| CHECK_RESULT(ReadInitExpr(global_index)); ------------------ | | 55| 222| do { \ | | 56| 222| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 33, False: 189] | | ------------------ | | 57| 33| return ::wabt::Result::Error; \ | | 58| 33| } \ | | 59| 222| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2661| 189| CALLBACK(EndGlobalInitExpr, global_index); ------------------ | | 61| 189| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 189|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 189| do { \ | | | | | | 42| 189| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 189] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 189| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 189| #member " callback failed") ------------------ 2662| 189| CALLBACK(EndGlobal, global_index); ------------------ | | 61| 189| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 189|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 189| do { \ | | | | | | 42| 189| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 189] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 189| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 189| #member " callback failed") ------------------ 2663| 189| } 2664| 30| CALLBACK0(EndGlobalSection); ------------------ | | 58| 30| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 30|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 30| do { \ | | | | | | 42| 30| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 30] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 30| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2665| 30| return Result::Ok; 2666| 30|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader12ReadInitExprEj: 567| 238|Result BinaryReader::ReadInitExpr(Index index) { 568| 238| CHECK_RESULT(ReadInstructions(read_end_, "init expression")); ------------------ | | 55| 238| do { \ | | 56| 238| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 34, False: 204] | | ------------------ | | 57| 34| return ::wabt::Result::Error; \ | | 58| 34| } \ | | 59| 238| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 569| 204| assert(state_.offset <= read_end_); 570| 204| return Result::Ok; 571| 204|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader16ReadInstructionsEmPKc: 674| 2.45k|Result BinaryReader::ReadInstructions(Offset end_offset, const char* context) { 675| 2.45k| std::stack nested_blocks; 676| 379k| while (state_.offset < end_offset) { ------------------ | Branch (676:10): [True: 379k, False: 42] ------------------ 677| 379k| Opcode opcode; 678| 379k| CHECK_RESULT(ReadOpcode(&opcode, "opcode")); ------------------ | | 55| 379k| do { \ | | 56| 379k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 6, False: 379k] | | ------------------ | | 57| 6| return ::wabt::Result::Error; \ | | 58| 6| } \ | | 59| 379k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 679| 379k| CALLBACK(OnOpcode, opcode); ------------------ | | 61| 379k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 379k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 379k| do { \ | | | | | | 42| 379k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 379k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 379k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 379k| #member " callback failed") ------------------ 680| 379k| ERROR_UNLESS_OPCODE_ENABLED(opcode); ------------------ | | 51| 379k| do { \ | | 52| 379k| if (!opcode.IsEnabled(options_.features)) { \ | | ------------------ | | | Branch (52:9): [True: 19, False: 379k] | | ------------------ | | 53| 19| return ReportUnexpectedOpcode(opcode); \ | | 54| 19| } \ | | 55| 379k| } while (0) | | ------------------ | | | Branch (55:12): [Folded - Ignored] | | ------------------ ------------------ 681| | 682| 379k| switch (opcode) { 683| 188k| case Opcode::Unreachable: ------------------ | Branch (683:7): [True: 188k, False: 191k] ------------------ 684| 188k| CALLBACK0(OnUnreachableExpr); ------------------ | | 58| 188k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 188k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 188k| do { \ | | | | | | 42| 188k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 2, False: 188k] | | | | | | ------------------ | | | | | | 43| 2| PrintError(__VA_ARGS__); \ | | | | | | 44| 2| return Result::Error; \ | | | | | | 45| 2| } \ | | | | | | 46| 188k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 685| 188k| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 188k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 188k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 188k| do { \ | | | | | | 42| 188k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 188k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 188k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 686| 188k| break; 687| | 688| 188k| case Opcode::Block: { ------------------ | Branch (688:7): [True: 1.85k, False: 377k] ------------------ 689| 1.85k| nested_blocks.push(opcode); 690| 1.85k| Type sig_type; 691| 1.85k| CHECK_RESULT(ReadType(&sig_type, "block signature type")); ------------------ | | 55| 1.85k| do { \ | | 56| 1.85k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 1.85k] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 1.85k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 692| 1.85k| ERROR_UNLESS(IsBlockType(sig_type), ------------------ | | 48| 1.85k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 1.85k| do { \ | | | | 42| 1.85k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 3, False: 1.84k] | | | | ------------------ | | | | 43| 3| PrintError(__VA_ARGS__); \ | | | | 44| 3| return Result::Error; \ | | | | 45| 3| } \ | | | | 46| 1.85k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 693| 1.84k| "expected valid block signature type"); 694| 1.84k| CALLBACK(OnBlockExpr, sig_type); ------------------ | | 61| 1.84k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.84k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.84k| do { \ | | | | | | 42| 1.84k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 7, False: 1.84k] | | | | | | ------------------ | | | | | | 43| 7| PrintError(__VA_ARGS__); \ | | | | | | 44| 7| return Result::Error; \ | | | | | | 45| 7| } \ | | | | | | 46| 1.84k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.84k| #member " callback failed") ------------------ 695| 1.84k| CALLBACK(OnOpcodeBlockSig, sig_type); ------------------ | | 61| 1.84k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.84k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.84k| do { \ | | | | | | 42| 1.84k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.84k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.84k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.84k| #member " callback failed") ------------------ 696| 1.84k| break; 697| 1.84k| } 698| | 699| 1.84k| case Opcode::Loop: { ------------------ | Branch (699:7): [True: 606, False: 379k] ------------------ 700| 606| nested_blocks.push(opcode); 701| 606| Type sig_type; 702| 606| CHECK_RESULT(ReadType(&sig_type, "loop signature type")); ------------------ | | 55| 606| do { \ | | 56| 606| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 605] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 606| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 703| 605| ERROR_UNLESS(IsBlockType(sig_type), ------------------ | | 48| 605|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 605| do { \ | | | | 42| 605| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 3, False: 602] | | | | ------------------ | | | | 43| 3| PrintError(__VA_ARGS__); \ | | | | 44| 3| return Result::Error; \ | | | | 45| 3| } \ | | | | 46| 605| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 704| 602| "expected valid block signature type"); 705| 602| CALLBACK(OnLoopExpr, sig_type); ------------------ | | 61| 602| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 602|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 602| do { \ | | | | | | 42| 602| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 2, False: 600] | | | | | | ------------------ | | | | | | 43| 2| PrintError(__VA_ARGS__); \ | | | | | | 44| 2| return Result::Error; \ | | | | | | 45| 2| } \ | | | | | | 46| 602| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 602| #member " callback failed") ------------------ 706| 600| CALLBACK(OnOpcodeBlockSig, sig_type); ------------------ | | 61| 600| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 600|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 600| do { \ | | | | | | 42| 600| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 600] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 600| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 600| #member " callback failed") ------------------ 707| 600| break; 708| 600| } 709| | 710| 600| case Opcode::If: { ------------------ | Branch (710:7): [True: 552, False: 379k] ------------------ 711| 552| nested_blocks.push(opcode); 712| 552| Type sig_type; 713| 552| CHECK_RESULT(ReadType(&sig_type, "if signature type")); ------------------ | | 55| 552| do { \ | | 56| 552| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 552] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 552| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 714| 552| ERROR_UNLESS(IsBlockType(sig_type), ------------------ | | 48| 552|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 552| do { \ | | | | 42| 552| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 552] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 552| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 715| 552| "expected valid block signature type"); 716| 552| CALLBACK(OnIfExpr, sig_type); ------------------ | | 61| 552| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 552|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 552| do { \ | | | | | | 42| 552| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 5, False: 547] | | | | | | ------------------ | | | | | | 43| 5| PrintError(__VA_ARGS__); \ | | | | | | 44| 5| return Result::Error; \ | | | | | | 45| 5| } \ | | | | | | 46| 552| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 552| #member " callback failed") ------------------ 717| 547| CALLBACK(OnOpcodeBlockSig, sig_type); ------------------ | | 61| 547| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 547|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 547| do { \ | | | | | | 42| 547| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 547| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 547| #member " callback failed") ------------------ 718| 547| break; 719| 547| } 720| | 721| 547| case Opcode::Else: ------------------ | Branch (721:7): [True: 187, False: 379k] ------------------ 722| 187| ERROR_IF(nested_blocks.empty() || (nested_blocks.top() != Opcode::If), ------------------ | | 41| 187| do { \ | | 42| 561| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 0, False: 187] | | | Branch (42:9): [True: 4, False: 183] | | ------------------ | | 43| 4| PrintError(__VA_ARGS__); \ | | 44| 4| return Result::Error; \ | | 45| 4| } \ | | 46| 187| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 723| 187| "else outside if block"); 724| 183| CALLBACK0(OnElseExpr); ------------------ | | 58| 183| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 183|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 183| do { \ | | | | | | 42| 183| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 183] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 183| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 725| 183| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 183| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 183|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 183| do { \ | | | | | | 42| 183| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 183] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 183| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 726| 183| break; 727| | 728| 183| case Opcode::SelectT: { ------------------ | Branch (728:7): [True: 52, False: 379k] ------------------ 729| 52| Index num_results; 730| 52| CHECK_RESULT(ReadCount(&num_results, "num result types")); ------------------ | | 55| 52| do { \ | | 56| 52| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 52] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 52| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 731| | 732| 52| result_types_.resize(num_results); 733| 102| for (Index i = 0; i < num_results; ++i) { ------------------ | Branch (733:27): [True: 51, False: 51] ------------------ 734| 51| Type result_type; 735| 51| CHECK_RESULT(ReadType(&result_type, "select result type")); ------------------ | | 55| 51| do { \ | | 56| 51| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 51] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 51| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 736| 51| ERROR_UNLESS(IsConcreteType(result_type), ------------------ | | 48| 51|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 51| do { \ | | | | 42| 51| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 1, False: 50] | | | | ------------------ | | | | 43| 2| PrintError(__VA_ARGS__); \ | | | | ------------------ | | | | | Branch (43:18): [True: 1, False: 0] | | | | ------------------ | | | | 44| 1| return Result::Error; \ | | | | 45| 1| } \ | | | | 46| 51| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 737| 50| "expected valid select result type (got " PRItypecode 738| 50| ")", 739| 50| WABT_PRINTF_TYPE_CODE(result_type)); 740| 50| result_types_[i] = result_type; 741| 50| } 742| | 743| 51| if (num_results) { ------------------ | Branch (743:13): [True: 50, False: 1] ------------------ 744| 50| CALLBACK(OnSelectExpr, num_results, result_types_.data()); ------------------ | | 61| 50| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 50|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 50| do { \ | | | | | | 42| 50| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 50] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 50| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 50| #member " callback failed") ------------------ 745| 50| CALLBACK(OnOpcodeType, result_types_[0]); ------------------ | | 61| 50| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 50|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 50| do { \ | | | | | | 42| 50| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 50] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 50| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 50| #member " callback failed") ------------------ 746| 50| } else { 747| 1| CALLBACK(OnSelectExpr, 0, NULL); ------------------ | | 61| 1| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1| do { \ | | | | | | 42| 1| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1| #member " callback failed") ------------------ 748| 1| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 1| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1| do { \ | | | | | | 42| 1| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 749| 1| } 750| 51| break; 751| 51| } 752| | 753| 915| case Opcode::Select: ------------------ | Branch (753:7): [True: 915, False: 378k] ------------------ 754| 915| CALLBACK(OnSelectExpr, 0, nullptr); ------------------ | | 61| 915| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 915|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 915| do { \ | | | | | | 42| 915| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 2, False: 913] | | | | | | ------------------ | | | | | | 43| 2| PrintError(__VA_ARGS__); \ | | | | | | 44| 2| return Result::Error; \ | | | | | | 45| 2| } \ | | | | | | 46| 915| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 915| #member " callback failed") ------------------ 755| 913| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 913| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 913|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 913| do { \ | | | | | | 42| 913| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 913] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 913| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 756| 913| break; 757| | 758| 913| case Opcode::Br: { ------------------ | Branch (758:7): [True: 481, False: 379k] ------------------ 759| 481| Index depth; 760| 481| CHECK_RESULT(ReadIndex(&depth, "br depth")); ------------------ | | 55| 481| do { \ | | 56| 481| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 481] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 481| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 761| 481| CALLBACK(OnBrExpr, depth); ------------------ | | 61| 481| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 481|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 481| do { \ | | | | | | 42| 481| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 5, False: 476] | | | | | | ------------------ | | | | | | 43| 5| PrintError(__VA_ARGS__); \ | | | | | | 44| 5| return Result::Error; \ | | | | | | 45| 5| } \ | | | | | | 46| 481| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 481| #member " callback failed") ------------------ 762| 476| CALLBACK(OnOpcodeIndex, depth); ------------------ | | 61| 476| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 476|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 476| do { \ | | | | | | 42| 476| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 476] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 476| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 476| #member " callback failed") ------------------ 763| 476| break; 764| 476| } 765| | 766| 476| case Opcode::BrIf: { ------------------ | Branch (766:7): [True: 48, False: 379k] ------------------ 767| 48| Index depth; 768| 48| CHECK_RESULT(ReadIndex(&depth, "br_if depth")); ------------------ | | 55| 48| do { \ | | 56| 48| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 48] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 48| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 769| 48| CALLBACK(OnBrIfExpr, depth); ------------------ | | 61| 48| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 48|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 48| do { \ | | | | | | 42| 48| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 1, False: 47] | | | | | | ------------------ | | | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | | | 44| 1| return Result::Error; \ | | | | | | 45| 1| } \ | | | | | | 46| 48| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 48| #member " callback failed") ------------------ 770| 47| CALLBACK(OnOpcodeIndex, depth); ------------------ | | 61| 47| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 47|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 47| do { \ | | | | | | 42| 47| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 47] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 47| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 47| #member " callback failed") ------------------ 771| 47| break; 772| 47| } 773| | 774| 1.36k| case Opcode::BrTable: { ------------------ | Branch (774:7): [True: 1.36k, False: 378k] ------------------ 775| 1.36k| Index num_targets; 776| 1.36k| CHECK_RESULT(ReadCount(&num_targets, "br_table target count")); ------------------ | | 55| 1.36k| do { \ | | 56| 1.36k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 1.35k] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 1.36k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 777| 1.35k| target_depths_.resize(num_targets); 778| | 779| 9.19k| for (Index i = 0; i < num_targets; ++i) { ------------------ | Branch (779:27): [True: 7.83k, False: 1.35k] ------------------ 780| 7.83k| Index target_depth; 781| 7.83k| CHECK_RESULT(ReadIndex(&target_depth, "br_table target depth")); ------------------ | | 55| 7.83k| do { \ | | 56| 7.83k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 7.83k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 7.83k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 782| 7.83k| target_depths_[i] = target_depth; 783| 7.83k| } 784| | 785| 1.35k| Index default_target_depth; 786| 1.35k| CHECK_RESULT( ------------------ | | 55| 1.35k| do { \ | | 56| 1.35k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.35k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.35k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 787| 1.35k| ReadIndex(&default_target_depth, "br_table default target depth")); 788| | 789| 1.35k| Index* target_depths = num_targets ? target_depths_.data() : nullptr; ------------------ | Branch (789:32): [True: 1.09k, False: 266] ------------------ 790| | 791| 1.35k| CALLBACK(OnBrTableExpr, num_targets, target_depths, ------------------ | | 61| 1.35k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.35k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.35k| do { \ | | | | | | 42| 1.35k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 14, False: 1.34k] | | | | | | ------------------ | | | | | | 43| 14| PrintError(__VA_ARGS__); \ | | | | | | 44| 14| return Result::Error; \ | | | | | | 45| 14| } \ | | | | | | 46| 1.35k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.35k| #member " callback failed") ------------------ 792| 1.34k| default_target_depth); 793| 1.34k| break; 794| 1.35k| } 795| | 796| 1.72k| case Opcode::Return: ------------------ | Branch (796:7): [True: 1.72k, False: 377k] ------------------ 797| 1.72k| CALLBACK0(OnReturnExpr); ------------------ | | 58| 1.72k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 1.72k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.72k| do { \ | | | | | | 42| 1.72k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.72k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.72k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 798| 1.72k| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 1.72k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 1.72k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.72k| do { \ | | | | | | 42| 1.72k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.72k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.72k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 799| 1.72k| break; 800| | 801| 32.7k| case Opcode::Nop: ------------------ | Branch (801:7): [True: 32.7k, False: 346k] ------------------ 802| 32.7k| CALLBACK0(OnNopExpr); ------------------ | | 58| 32.7k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 32.7k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 32.7k| do { \ | | | | | | 42| 32.7k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 32.7k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 32.7k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 803| 32.7k| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 32.7k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 32.7k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 32.7k| do { \ | | | | | | 42| 32.7k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 32.7k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 32.7k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 804| 32.7k| break; 805| | 806| 32.7k| case Opcode::Drop: ------------------ | Branch (806:7): [True: 94, False: 379k] ------------------ 807| 94| CALLBACK0(OnDropExpr); ------------------ | | 58| 94| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 94|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 94| do { \ | | | | | | 42| 94| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 94] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 94| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 808| 94| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 94| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 94|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 94| do { \ | | | | | | 42| 94| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 94] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 94| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 809| 94| break; 810| | 811| 2.84k| case Opcode::End: ------------------ | Branch (811:7): [True: 2.84k, False: 376k] ------------------ 812| 2.84k| CALLBACK0(OnEndExpr); ------------------ | | 58| 2.84k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 2.84k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.84k| do { \ | | | | | | 42| 2.84k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 3, False: 2.83k] | | | | | | ------------------ | | | | | | 43| 3| PrintError(__VA_ARGS__); \ | | | | | | 44| 3| return Result::Error; \ | | | | | | 45| 3| } \ | | | | | | 46| 2.84k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 813| 2.83k| if (nested_blocks.empty()) { ------------------ | Branch (813:13): [True: 2.06k, False: 773] ------------------ 814| 2.06k| return Result::Ok; 815| 2.06k| } 816| 773| nested_blocks.pop(); 817| 773| break; 818| | 819| 23.8k| case Opcode::I32Const: { ------------------ | Branch (819:7): [True: 23.8k, False: 355k] ------------------ 820| 23.8k| uint32_t value; 821| 23.8k| CHECK_RESULT(ReadS32Leb128(&value, "i32.const value")); ------------------ | | 55| 23.8k| do { \ | | 56| 23.8k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5, False: 23.8k] | | ------------------ | | 57| 5| return ::wabt::Result::Error; \ | | 58| 5| } \ | | 59| 23.8k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 822| 23.8k| CALLBACK(OnI32ConstExpr, value); ------------------ | | 61| 23.8k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 23.8k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 23.8k| do { \ | | | | | | 42| 23.8k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 23.8k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 23.8k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 23.8k| #member " callback failed") ------------------ 823| 23.8k| CALLBACK(OnOpcodeUint32, value); ------------------ | | 61| 23.8k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 23.8k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 23.8k| do { \ | | | | | | 42| 23.8k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 23.8k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 23.8k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 23.8k| #member " callback failed") ------------------ 824| 23.8k| break; 825| 23.8k| } 826| | 827| 23.8k| case Opcode::I64Const: { ------------------ | Branch (827:7): [True: 574, False: 379k] ------------------ 828| 574| uint64_t value; 829| 574| CHECK_RESULT(ReadS64Leb128(&value, "i64.const value")); ------------------ | | 55| 574| do { \ | | 56| 574| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 574] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 574| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 830| 574| CALLBACK(OnI64ConstExpr, value); ------------------ | | 61| 574| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 574|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 574| do { \ | | | | | | 42| 574| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 574] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 574| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 574| #member " callback failed") ------------------ 831| 574| CALLBACK(OnOpcodeUint64, value); ------------------ | | 61| 574| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 574|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 574| do { \ | | | | | | 42| 574| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 574] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 574| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 574| #member " callback failed") ------------------ 832| 574| break; 833| 574| } 834| | 835| 2.11k| case Opcode::F32Const: { ------------------ | Branch (835:7): [True: 2.11k, False: 377k] ------------------ 836| 2.11k| uint32_t value_bits = 0; 837| 2.11k| CHECK_RESULT(ReadF32(&value_bits, "f32.const value")); ------------------ | | 55| 2.11k| do { \ | | 56| 2.11k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2.11k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2.11k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 838| 2.11k| CALLBACK(OnF32ConstExpr, value_bits); ------------------ | | 61| 2.11k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2.11k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.11k| do { \ | | | | | | 42| 2.11k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2.11k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2.11k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2.11k| #member " callback failed") ------------------ 839| 2.11k| CALLBACK(OnOpcodeF32, value_bits); ------------------ | | 61| 2.11k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2.11k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.11k| do { \ | | | | | | 42| 2.11k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2.11k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2.11k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2.11k| #member " callback failed") ------------------ 840| 2.11k| break; 841| 2.11k| } 842| | 843| 2.11k| case Opcode::F64Const: { ------------------ | Branch (843:7): [True: 136, False: 379k] ------------------ 844| 136| uint64_t value_bits = 0; 845| 136| CHECK_RESULT(ReadF64(&value_bits, "f64.const value")); ------------------ | | 55| 136| do { \ | | 56| 136| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 136] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 136| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 846| 136| CALLBACK(OnF64ConstExpr, value_bits); ------------------ | | 61| 136| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 136|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 136| do { \ | | | | | | 42| 136| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 136] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 136| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 136| #member " callback failed") ------------------ 847| 136| CALLBACK(OnOpcodeF64, value_bits); ------------------ | | 61| 136| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 136|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 136| do { \ | | | | | | 42| 136| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 136] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 136| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 136| #member " callback failed") ------------------ 848| 136| break; 849| 136| } 850| | 851| 136| case Opcode::V128Const: { ------------------ | Branch (851:7): [True: 22, False: 379k] ------------------ 852| 22| v128 value_bits; 853| 22| ZeroMemory(value_bits); 854| 22| CHECK_RESULT(ReadV128(&value_bits, "v128.const value")); ------------------ | | 55| 22| do { \ | | 56| 22| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 22] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 22| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 855| 22| CALLBACK(OnV128ConstExpr, value_bits); ------------------ | | 61| 22| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 22|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 22| do { \ | | | | | | 42| 22| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 22] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 22| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 22| #member " callback failed") ------------------ 856| 22| CALLBACK(OnOpcodeV128, value_bits); ------------------ | | 61| 22| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 22|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 22| do { \ | | | | | | 42| 22| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 22] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 22| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 22| #member " callback failed") ------------------ 857| 22| break; 858| 22| } 859| | 860| 197| case Opcode::GlobalGet: { ------------------ | Branch (860:7): [True: 197, False: 379k] ------------------ 861| 197| Index global_index; 862| 197| CHECK_RESULT(ReadIndex(&global_index, "global.get global index")); ------------------ | | 55| 197| do { \ | | 56| 197| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 197] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 197| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 863| 197| CALLBACK(OnGlobalGetExpr, global_index); ------------------ | | 61| 197| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 197|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 197| do { \ | | | | | | 42| 197| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 3, False: 194] | | | | | | ------------------ | | | | | | 43| 3| PrintError(__VA_ARGS__); \ | | | | | | 44| 3| return Result::Error; \ | | | | | | 45| 3| } \ | | | | | | 46| 197| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 197| #member " callback failed") ------------------ 864| 194| CALLBACK(OnOpcodeIndex, global_index); ------------------ | | 61| 194| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 194|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 194| do { \ | | | | | | 42| 194| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 194] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 194| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 194| #member " callback failed") ------------------ 865| 194| break; 866| 194| } 867| | 868| 1.94k| case Opcode::LocalGet: { ------------------ | Branch (868:7): [True: 1.94k, False: 377k] ------------------ 869| 1.94k| Index local_index; 870| 1.94k| CHECK_RESULT(ReadIndex(&local_index, "local.get local index")); ------------------ | | 55| 1.94k| do { \ | | 56| 1.94k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.94k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.94k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 871| 1.94k| CALLBACK(OnLocalGetExpr, local_index); ------------------ | | 61| 1.94k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.94k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.94k| do { \ | | | | | | 42| 1.94k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 7, False: 1.93k] | | | | | | ------------------ | | | | | | 43| 7| PrintError(__VA_ARGS__); \ | | | | | | 44| 7| return Result::Error; \ | | | | | | 45| 7| } \ | | | | | | 46| 1.94k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.94k| #member " callback failed") ------------------ 872| 1.93k| CALLBACK(OnOpcodeIndex, local_index); ------------------ | | 61| 1.93k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.93k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.93k| do { \ | | | | | | 42| 1.93k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.93k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.93k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.93k| #member " callback failed") ------------------ 873| 1.93k| break; 874| 1.93k| } 875| | 876| 1.93k| case Opcode::GlobalSet: { ------------------ | Branch (876:7): [True: 33, False: 379k] ------------------ 877| 33| Index global_index; 878| 33| CHECK_RESULT(ReadIndex(&global_index, "global.set global index")); ------------------ | | 55| 33| do { \ | | 56| 33| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 33] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 33| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 879| 33| CALLBACK(OnGlobalSetExpr, global_index); ------------------ | | 61| 33| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 33|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 33| do { \ | | | | | | 42| 33| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 3, False: 30] | | | | | | ------------------ | | | | | | 43| 3| PrintError(__VA_ARGS__); \ | | | | | | 44| 3| return Result::Error; \ | | | | | | 45| 3| } \ | | | | | | 46| 33| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 33| #member " callback failed") ------------------ 880| 30| CALLBACK(OnOpcodeIndex, global_index); ------------------ | | 61| 30| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 30|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 30| do { \ | | | | | | 42| 30| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 30] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 30| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 30| #member " callback failed") ------------------ 881| 30| break; 882| 30| } 883| | 884| 729| case Opcode::LocalSet: { ------------------ | Branch (884:7): [True: 729, False: 378k] ------------------ 885| 729| Index local_index; 886| 729| CHECK_RESULT(ReadIndex(&local_index, "local.set local index")); ------------------ | | 55| 729| do { \ | | 56| 729| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 729] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 729| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 887| 729| CALLBACK(OnLocalSetExpr, local_index); ------------------ | | 61| 729| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 729|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 729| do { \ | | | | | | 42| 729| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 2, False: 727] | | | | | | ------------------ | | | | | | 43| 2| PrintError(__VA_ARGS__); \ | | | | | | 44| 2| return Result::Error; \ | | | | | | 45| 2| } \ | | | | | | 46| 729| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 729| #member " callback failed") ------------------ 888| 727| CALLBACK(OnOpcodeIndex, local_index); ------------------ | | 61| 727| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 727|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 727| do { \ | | | | | | 42| 727| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 727] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 727| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 727| #member " callback failed") ------------------ 889| 727| break; 890| 727| } 891| | 892| 727| case Opcode::Call: { ------------------ | Branch (892:7): [True: 643, False: 379k] ------------------ 893| 643| Index func_index; 894| 643| CHECK_RESULT(ReadIndex(&func_index, "call function index")); ------------------ | | 55| 643| do { \ | | 56| 643| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 643] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 643| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 895| 643| CALLBACK(OnCallExpr, func_index); ------------------ | | 61| 643| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 643|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 643| do { \ | | | | | | 42| 643| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 3, False: 640] | | | | | | ------------------ | | | | | | 43| 3| PrintError(__VA_ARGS__); \ | | | | | | 44| 3| return Result::Error; \ | | | | | | 45| 3| } \ | | | | | | 46| 643| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 643| #member " callback failed") ------------------ 896| 640| CALLBACK(OnOpcodeIndex, func_index); ------------------ | | 61| 640| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 640|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 640| do { \ | | | | | | 42| 640| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 640] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 640| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 640| #member " callback failed") ------------------ 897| 640| break; 898| 640| } 899| | 900| 640| case Opcode::CallIndirect: { ------------------ | Branch (900:7): [True: 340, False: 379k] ------------------ 901| 340| Index sig_index; 902| 340| CHECK_RESULT(ReadIndex(&sig_index, "call_indirect signature index")); ------------------ | | 55| 340| do { \ | | 56| 340| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 339] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 340| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 903| 339| Index table_index = 0; 904| 339| if (options_.features.reference_types_enabled()) { ------------------ | Branch (904:13): [True: 339, False: 0] ------------------ 905| 339| CHECK_RESULT(ReadIndex(&table_index, "call_indirect table index")); ------------------ | | 55| 339| do { \ | | 56| 339| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 338] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 339| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 906| 339| } else { 907| 0| uint8_t reserved; 908| 0| CHECK_RESULT(ReadU8(&reserved, "call_indirect reserved")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 909| 0| ERROR_UNLESS(reserved == 0, "call_indirect reserved value must be 0"); ------------------ | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 0| do { \ | | | | 42| 0| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 0| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 910| 0| } 911| 338| CALLBACK(OnCallIndirectExpr, sig_index, table_index); ------------------ | | 61| 338| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 338|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 338| do { \ | | | | | | 42| 338| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 2, False: 336] | | | | | | ------------------ | | | | | | 43| 2| PrintError(__VA_ARGS__); \ | | | | | | 44| 2| return Result::Error; \ | | | | | | 45| 2| } \ | | | | | | 46| 338| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 338| #member " callback failed") ------------------ 912| 336| CALLBACK(OnOpcodeUint32Uint32, sig_index, table_index); ------------------ | | 61| 336| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 336|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 336| do { \ | | | | | | 42| 336| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 336] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 336| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 336| #member " callback failed") ------------------ 913| 336| break; 914| 336| } 915| | 916| 336| case Opcode::ReturnCall: { ------------------ | Branch (916:7): [True: 2, False: 379k] ------------------ 917| 2| Index func_index; 918| 2| CHECK_RESULT(ReadIndex(&func_index, "return_call")); ------------------ | | 55| 2| do { \ | | 56| 2| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 919| 2| CALLBACK(OnReturnCallExpr, func_index); ------------------ | | 61| 2| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2| do { \ | | | | | | 42| 2| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2| #member " callback failed") ------------------ 920| 2| CALLBACK(OnOpcodeIndex, func_index); ------------------ | | 61| 2| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2| do { \ | | | | | | 42| 2| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2| #member " callback failed") ------------------ 921| 2| break; 922| 2| } 923| | 924| 114| case Opcode::ReturnCallIndirect: { ------------------ | Branch (924:7): [True: 114, False: 379k] ------------------ 925| 114| Index sig_index; 926| 114| CHECK_RESULT(ReadIndex(&sig_index, "return_call_indirect")); ------------------ | | 55| 114| do { \ | | 56| 114| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 114] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 114| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 927| 114| Index table_index = 0; 928| 114| if (options_.features.reference_types_enabled()) { ------------------ | Branch (928:13): [True: 114, False: 0] ------------------ 929| 114| CHECK_RESULT( ------------------ | | 55| 114| do { \ | | 56| 114| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 114] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 114| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 930| 114| ReadIndex(&table_index, "return_call_indirect table index")); 931| 114| } else { 932| 0| uint8_t reserved; 933| 0| CHECK_RESULT(ReadU8(&reserved, "return_call_indirect reserved")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 934| 0| ERROR_UNLESS(reserved == 0, ------------------ | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 0| do { \ | | | | 42| 0| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 0| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 935| 0| "return_call_indirect reserved value must be 0"); 936| 0| } 937| 114| CALLBACK(OnReturnCallIndirectExpr, sig_index, table_index); ------------------ | | 61| 114| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 114|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 114| do { \ | | | | | | 42| 114| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 6, False: 108] | | | | | | ------------------ | | | | | | 43| 6| PrintError(__VA_ARGS__); \ | | | | | | 44| 6| return Result::Error; \ | | | | | | 45| 6| } \ | | | | | | 46| 114| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 114| #member " callback failed") ------------------ 938| 108| CALLBACK(OnOpcodeUint32Uint32, sig_index, table_index); ------------------ | | 61| 108| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 108|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 108| do { \ | | | | | | 42| 108| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 108] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 108| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 108| #member " callback failed") ------------------ 939| 108| break; 940| 108| } 941| | 942| 108| case Opcode::LocalTee: { ------------------ | Branch (942:7): [True: 47, False: 379k] ------------------ 943| 47| Index local_index; 944| 47| CHECK_RESULT(ReadIndex(&local_index, "local.tee local index")); ------------------ | | 55| 47| do { \ | | 56| 47| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 47] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 47| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 945| 47| CALLBACK(OnLocalTeeExpr, local_index); ------------------ | | 61| 47| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 47|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 47| do { \ | | | | | | 42| 47| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 1, False: 46] | | | | | | ------------------ | | | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | | | 44| 1| return Result::Error; \ | | | | | | 45| 1| } \ | | | | | | 46| 47| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 47| #member " callback failed") ------------------ 946| 46| CALLBACK(OnOpcodeIndex, local_index); ------------------ | | 61| 46| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 46|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 46| do { \ | | | | | | 42| 46| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 46] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 46| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 46| #member " callback failed") ------------------ 947| 46| break; 948| 46| } 949| | 950| 46| case Opcode::I32Load8S: ------------------ | Branch (950:7): [True: 12, False: 379k] ------------------ 951| 48| case Opcode::I32Load8U: ------------------ | Branch (951:7): [True: 36, False: 379k] ------------------ 952| 93| case Opcode::I32Load16S: ------------------ | Branch (952:7): [True: 45, False: 379k] ------------------ 953| 133| case Opcode::I32Load16U: ------------------ | Branch (953:7): [True: 40, False: 379k] ------------------ 954| 164| case Opcode::I64Load8S: ------------------ | Branch (954:7): [True: 31, False: 379k] ------------------ 955| 181| case Opcode::I64Load8U: ------------------ | Branch (955:7): [True: 17, False: 379k] ------------------ 956| 196| case Opcode::I64Load16S: ------------------ | Branch (956:7): [True: 15, False: 379k] ------------------ 957| 208| case Opcode::I64Load16U: ------------------ | Branch (957:7): [True: 12, False: 379k] ------------------ 958| 224| case Opcode::I64Load32S: ------------------ | Branch (958:7): [True: 16, False: 379k] ------------------ 959| 230| case Opcode::I64Load32U: ------------------ | Branch (959:7): [True: 6, False: 379k] ------------------ 960| 302| case Opcode::I32Load: ------------------ | Branch (960:7): [True: 72, False: 379k] ------------------ 961| 1.03k| case Opcode::I64Load: ------------------ | Branch (961:7): [True: 736, False: 378k] ------------------ 962| 1.15k| case Opcode::F32Load: ------------------ | Branch (962:7): [True: 112, False: 379k] ------------------ 963| 1.17k| case Opcode::F64Load: ------------------ | Branch (963:7): [True: 21, False: 379k] ------------------ 964| 3.79k| case Opcode::V128Load: ------------------ | Branch (964:7): [True: 2.62k, False: 377k] ------------------ 965| 3.90k| case Opcode::V128Load8X8S: ------------------ | Branch (965:7): [True: 105, False: 379k] ------------------ 966| 3.99k| case Opcode::V128Load8X8U: ------------------ | Branch (966:7): [True: 91, False: 379k] ------------------ 967| 4.04k| case Opcode::V128Load16X4S: ------------------ | Branch (967:7): [True: 54, False: 379k] ------------------ 968| 4.10k| case Opcode::V128Load16X4U: ------------------ | Branch (968:7): [True: 56, False: 379k] ------------------ 969| 4.16k| case Opcode::V128Load32X2S: ------------------ | Branch (969:7): [True: 62, False: 379k] ------------------ 970| 4.20k| case Opcode::V128Load32X2U: { ------------------ | Branch (970:7): [True: 34, False: 379k] ------------------ 971| 4.20k| Address alignment_log2; 972| 4.20k| Index memidx; 973| 4.20k| Address offset; 974| 4.20k| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 4.20k| do { \ | | 56| 4.20k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 14, False: 4.18k] | | ------------------ | | 57| 14| return ::wabt::Result::Error; \ | | 58| 14| } \ | | 59| 4.20k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 975| 4.20k| "load alignment", "load memidx", 976| 4.20k| "load offset")); 977| 4.18k| CALLBACK(OnLoadExpr, opcode, memidx, alignment_log2, offset); ------------------ | | 61| 4.18k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 4.18k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 4.18k| do { \ | | | | | | 42| 4.18k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 29, False: 4.15k] | | | | | | ------------------ | | | | | | 43| 29| PrintError(__VA_ARGS__); \ | | | | | | 44| 29| return Result::Error; \ | | | | | | 45| 29| } \ | | | | | | 46| 4.18k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 4.18k| #member " callback failed") ------------------ 978| 4.15k| CHECK_RESULT(CallbackMemLocation(&alignment_log2, &memidx, &offset)); ------------------ | | 55| 4.15k| do { \ | | 56| 4.15k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4.15k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4.15k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 979| 4.15k| break; 980| 4.15k| } 981| | 982| 4.15k| case Opcode::I32Store8: ------------------ | Branch (982:7): [True: 9, False: 379k] ------------------ 983| 179| case Opcode::I32Store16: ------------------ | Branch (983:7): [True: 170, False: 379k] ------------------ 984| 179| case Opcode::I64Store8: ------------------ | Branch (984:7): [True: 0, False: 379k] ------------------ 985| 180| case Opcode::I64Store16: ------------------ | Branch (985:7): [True: 1, False: 379k] ------------------ 986| 181| case Opcode::I64Store32: ------------------ | Branch (986:7): [True: 1, False: 379k] ------------------ 987| 188| case Opcode::I32Store: ------------------ | Branch (987:7): [True: 7, False: 379k] ------------------ 988| 196| case Opcode::I64Store: ------------------ | Branch (988:7): [True: 8, False: 379k] ------------------ 989| 197| case Opcode::F32Store: ------------------ | Branch (989:7): [True: 1, False: 379k] ------------------ 990| 307| case Opcode::F64Store: ------------------ | Branch (990:7): [True: 110, False: 379k] ------------------ 991| 333| case Opcode::V128Store: { ------------------ | Branch (991:7): [True: 26, False: 379k] ------------------ 992| 333| Address alignment_log2; 993| 333| Index memidx; 994| 333| Address offset; 995| 333| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 333| do { \ | | 56| 333| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 333] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 333| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 996| 333| "store alignment", "store memidx", 997| 333| "store offset")); 998| 333| CALLBACK(OnStoreExpr, opcode, memidx, alignment_log2, offset); ------------------ | | 61| 333| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 333|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 333| do { \ | | | | | | 42| 333| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 4, False: 329] | | | | | | ------------------ | | | | | | 43| 4| PrintError(__VA_ARGS__); \ | | | | | | 44| 4| return Result::Error; \ | | | | | | 45| 4| } \ | | | | | | 46| 333| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 333| #member " callback failed") ------------------ 999| 329| CHECK_RESULT(CallbackMemLocation(&alignment_log2, &memidx, &offset)); ------------------ | | 55| 329| do { \ | | 56| 329| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 329] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 329| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1000| 329| break; 1001| 329| } 1002| | 1003| 329| case Opcode::MemorySize: { ------------------ | Branch (1003:7): [True: 5, False: 379k] ------------------ 1004| 5| Index memidx = 0; 1005| 5| if (!options_.features.multi_memory_enabled()) { ------------------ | Branch (1005:13): [True: 3, False: 2] ------------------ 1006| 3| uint8_t reserved; 1007| 3| CHECK_RESULT(ReadU8(&reserved, "memory.size reserved")); ------------------ | | 55| 3| do { \ | | 56| 3| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 3] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 3| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1008| 3| ERROR_UNLESS(reserved == 0, "memory.size reserved value must be 0"); ------------------ | | 48| 3|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 3| do { \ | | | | 42| 3| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 1, False: 2] | | | | ------------------ | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | 44| 1| return Result::Error; \ | | | | 45| 1| } \ | | | | 46| 3| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1009| 3| } else { 1010| 2| CHECK_RESULT(ReadMemidx(&memidx, "memory.size memidx")); ------------------ | | 55| 2| do { \ | | 56| 2| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1011| 2| } 1012| 4| CALLBACK(OnMemorySizeExpr, memidx); ------------------ | | 61| 4| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 4|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 4| do { \ | | | | | | 42| 4| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 4| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 4| #member " callback failed") ------------------ 1013| 4| CALLBACK(OnOpcodeUint32, memidx); ------------------ | | 61| 4| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 4|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 4| do { \ | | | | | | 42| 4| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 4| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 4| #member " callback failed") ------------------ 1014| 4| break; 1015| 4| } 1016| | 1017| 98| case Opcode::MemoryGrow: { ------------------ | Branch (1017:7): [True: 98, False: 379k] ------------------ 1018| 98| Index memidx = 0; 1019| 98| if (!options_.features.multi_memory_enabled()) { ------------------ | Branch (1019:13): [True: 20, False: 78] ------------------ 1020| 20| uint8_t reserved; 1021| 20| CHECK_RESULT(ReadU8(&reserved, "memory.grow reserved")); ------------------ | | 55| 20| do { \ | | 56| 20| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 20] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 20| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1022| 20| ERROR_UNLESS(reserved == 0, "memory.grow reserved value must be 0"); ------------------ | | 48| 20|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 20| do { \ | | | | 42| 20| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 4, False: 16] | | | | ------------------ | | | | 43| 4| PrintError(__VA_ARGS__); \ | | | | 44| 4| return Result::Error; \ | | | | 45| 4| } \ | | | | 46| 20| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1023| 78| } else { 1024| 78| CHECK_RESULT(ReadMemidx(&memidx, "memory.grow memidx")); ------------------ | | 55| 78| do { \ | | 56| 78| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 78] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 78| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1025| 78| } 1026| 94| CALLBACK(OnMemoryGrowExpr, memidx); ------------------ | | 61| 94| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 94|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 94| do { \ | | | | | | 42| 94| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 2, False: 92] | | | | | | ------------------ | | | | | | 43| 2| PrintError(__VA_ARGS__); \ | | | | | | 44| 2| return Result::Error; \ | | | | | | 45| 2| } \ | | | | | | 46| 94| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 94| #member " callback failed") ------------------ 1027| 92| CALLBACK(OnOpcodeUint32, memidx); ------------------ | | 61| 92| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 92|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 92| do { \ | | | | | | 42| 92| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 92] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 92| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 92| #member " callback failed") ------------------ 1028| 92| break; 1029| 92| } 1030| | 1031| 92| case Opcode::I32Add: ------------------ | Branch (1031:7): [True: 84, False: 379k] ------------------ 1032| 122| case Opcode::I32Sub: ------------------ | Branch (1032:7): [True: 38, False: 379k] ------------------ 1033| 239| case Opcode::I32Mul: ------------------ | Branch (1033:7): [True: 117, False: 379k] ------------------ 1034| 422| case Opcode::I32DivS: ------------------ | Branch (1034:7): [True: 183, False: 379k] ------------------ 1035| 3.53k| case Opcode::I32DivU: ------------------ | Branch (1035:7): [True: 3.11k, False: 376k] ------------------ 1036| 3.59k| case Opcode::I32RemS: ------------------ | Branch (1036:7): [True: 58, False: 379k] ------------------ 1037| 3.60k| case Opcode::I32RemU: ------------------ | Branch (1037:7): [True: 9, False: 379k] ------------------ 1038| 4.12k| case Opcode::I32And: ------------------ | Branch (1038:7): [True: 524, False: 379k] ------------------ 1039| 28.9k| case Opcode::I32Or: ------------------ | Branch (1039:7): [True: 24.8k, False: 354k] ------------------ 1040| 29.2k| case Opcode::I32Xor: ------------------ | Branch (1040:7): [True: 301, False: 379k] ------------------ 1041| 29.3k| case Opcode::I32Shl: ------------------ | Branch (1041:7): [True: 93, False: 379k] ------------------ 1042| 29.8k| case Opcode::I32ShrU: ------------------ | Branch (1042:7): [True: 464, False: 379k] ------------------ 1043| 29.8k| case Opcode::I32ShrS: ------------------ | Branch (1043:7): [True: 0, False: 379k] ------------------ 1044| 29.8k| case Opcode::I32Rotr: ------------------ | Branch (1044:7): [True: 40, False: 379k] ------------------ 1045| 35.3k| case Opcode::I32Rotl: ------------------ | Branch (1045:7): [True: 5.49k, False: 374k] ------------------ 1046| 35.3k| case Opcode::I64Add: ------------------ | Branch (1046:7): [True: 21, False: 379k] ------------------ 1047| 35.4k| case Opcode::I64Sub: ------------------ | Branch (1047:7): [True: 14, False: 379k] ------------------ 1048| 35.4k| case Opcode::I64Mul: ------------------ | Branch (1048:7): [True: 13, False: 379k] ------------------ 1049| 35.7k| case Opcode::I64DivS: ------------------ | Branch (1049:7): [True: 372, False: 379k] ------------------ 1050| 37.8k| case Opcode::I64DivU: ------------------ | Branch (1050:7): [True: 2.09k, False: 377k] ------------------ 1051| 38.0k| case Opcode::I64RemS: ------------------ | Branch (1051:7): [True: 219, False: 379k] ------------------ 1052| 38.0k| case Opcode::I64RemU: ------------------ | Branch (1052:7): [True: 3, False: 379k] ------------------ 1053| 38.2k| case Opcode::I64And: ------------------ | Branch (1053:7): [True: 164, False: 379k] ------------------ 1054| 38.5k| case Opcode::I64Or: ------------------ | Branch (1054:7): [True: 256, False: 379k] ------------------ 1055| 38.6k| case Opcode::I64Xor: ------------------ | Branch (1055:7): [True: 165, False: 379k] ------------------ 1056| 38.6k| case Opcode::I64Shl: ------------------ | Branch (1056:7): [True: 4, False: 379k] ------------------ 1057| 38.6k| case Opcode::I64ShrU: ------------------ | Branch (1057:7): [True: 6, False: 379k] ------------------ 1058| 38.9k| case Opcode::I64ShrS: ------------------ | Branch (1058:7): [True: 282, False: 379k] ------------------ 1059| 39.1k| case Opcode::I64Rotr: ------------------ | Branch (1059:7): [True: 142, False: 379k] ------------------ 1060| 39.1k| case Opcode::I64Rotl: ------------------ | Branch (1060:7): [True: 56, False: 379k] ------------------ 1061| 39.1k| case Opcode::F32Add: ------------------ | Branch (1061:7): [True: 3, False: 379k] ------------------ 1062| 39.1k| case Opcode::F32Sub: ------------------ | Branch (1062:7): [True: 9, False: 379k] ------------------ 1063| 39.3k| case Opcode::F32Mul: ------------------ | Branch (1063:7): [True: 208, False: 379k] ------------------ 1064| 39.3k| case Opcode::F32Div: ------------------ | Branch (1064:7): [True: 1, False: 379k] ------------------ 1065| 39.4k| case Opcode::F32Min: ------------------ | Branch (1065:7): [True: 20, False: 379k] ------------------ 1066| 39.8k| case Opcode::F32Max: ------------------ | Branch (1066:7): [True: 400, False: 379k] ------------------ 1067| 39.8k| case Opcode::F32Copysign: ------------------ | Branch (1067:7): [True: 7, False: 379k] ------------------ 1068| 39.8k| case Opcode::F64Add: ------------------ | Branch (1068:7): [True: 1, False: 379k] ------------------ 1069| 39.8k| case Opcode::F64Sub: ------------------ | Branch (1069:7): [True: 1, False: 379k] ------------------ 1070| 39.8k| case Opcode::F64Mul: ------------------ | Branch (1070:7): [True: 1, False: 379k] ------------------ 1071| 40.2k| case Opcode::F64Div: ------------------ | Branch (1071:7): [True: 383, False: 379k] ------------------ 1072| 40.2k| case Opcode::F64Min: ------------------ | Branch (1072:7): [True: 20, False: 379k] ------------------ 1073| 40.2k| case Opcode::F64Max: ------------------ | Branch (1073:7): [True: 0, False: 379k] ------------------ 1074| 40.2k| case Opcode::F64Copysign: ------------------ | Branch (1074:7): [True: 0, False: 379k] ------------------ 1075| 40.2k| case Opcode::I8X16Add: ------------------ | Branch (1075:7): [True: 0, False: 379k] ------------------ 1076| 40.2k| case Opcode::I16X8Add: ------------------ | Branch (1076:7): [True: 39, False: 379k] ------------------ 1077| 40.2k| case Opcode::I32X4Add: ------------------ | Branch (1077:7): [True: 2, False: 379k] ------------------ 1078| 40.2k| case Opcode::I64X2Add: ------------------ | Branch (1078:7): [True: 0, False: 379k] ------------------ 1079| 40.2k| case Opcode::I8X16Sub: ------------------ | Branch (1079:7): [True: 5, False: 379k] ------------------ 1080| 40.2k| case Opcode::I16X8Sub: ------------------ | Branch (1080:7): [True: 0, False: 379k] ------------------ 1081| 40.2k| case Opcode::I32X4Sub: ------------------ | Branch (1081:7): [True: 2, False: 379k] ------------------ 1082| 40.2k| case Opcode::I64X2Sub: ------------------ | Branch (1082:7): [True: 21, False: 379k] ------------------ 1083| 40.2k| case Opcode::I16X8Mul: ------------------ | Branch (1083:7): [True: 0, False: 379k] ------------------ 1084| 40.3k| case Opcode::I32X4Mul: ------------------ | Branch (1084:7): [True: 3, False: 379k] ------------------ 1085| 40.3k| case Opcode::I64X2Mul: ------------------ | Branch (1085:7): [True: 2, False: 379k] ------------------ 1086| 40.3k| case Opcode::I8X16AddSatS: ------------------ | Branch (1086:7): [True: 11, False: 379k] ------------------ 1087| 40.3k| case Opcode::I8X16AddSatU: ------------------ | Branch (1087:7): [True: 0, False: 379k] ------------------ 1088| 40.4k| case Opcode::I16X8AddSatS: ------------------ | Branch (1088:7): [True: 131, False: 379k] ------------------ 1089| 40.4k| case Opcode::I16X8AddSatU: ------------------ | Branch (1089:7): [True: 0, False: 379k] ------------------ 1090| 40.4k| case Opcode::I8X16SubSatS: ------------------ | Branch (1090:7): [True: 0, False: 379k] ------------------ 1091| 40.4k| case Opcode::I8X16SubSatU: ------------------ | Branch (1091:7): [True: 1, False: 379k] ------------------ 1092| 40.4k| case Opcode::I16X8SubSatS: ------------------ | Branch (1092:7): [True: 0, False: 379k] ------------------ 1093| 40.4k| case Opcode::I16X8SubSatU: ------------------ | Branch (1093:7): [True: 0, False: 379k] ------------------ 1094| 40.4k| case Opcode::I8X16MinS: ------------------ | Branch (1094:7): [True: 29, False: 379k] ------------------ 1095| 40.4k| case Opcode::I16X8MinS: ------------------ | Branch (1095:7): [True: 0, False: 379k] ------------------ 1096| 40.4k| case Opcode::I32X4MinS: ------------------ | Branch (1096:7): [True: 0, False: 379k] ------------------ 1097| 41.0k| case Opcode::I8X16MinU: ------------------ | Branch (1097:7): [True: 554, False: 379k] ------------------ 1098| 41.0k| case Opcode::I16X8MinU: ------------------ | Branch (1098:7): [True: 0, False: 379k] ------------------ 1099| 41.0k| case Opcode::I32X4MinU: ------------------ | Branch (1099:7): [True: 0, False: 379k] ------------------ 1100| 41.0k| case Opcode::I8X16MaxS: ------------------ | Branch (1100:7): [True: 10, False: 379k] ------------------ 1101| 41.1k| case Opcode::I16X8MaxS: ------------------ | Branch (1101:7): [True: 99, False: 379k] ------------------ 1102| 41.5k| case Opcode::I32X4MaxS: ------------------ | Branch (1102:7): [True: 412, False: 379k] ------------------ 1103| 41.5k| case Opcode::I8X16MaxU: ------------------ | Branch (1103:7): [True: 4, False: 379k] ------------------ 1104| 43.1k| case Opcode::I16X8MaxU: ------------------ | Branch (1104:7): [True: 1.60k, False: 378k] ------------------ 1105| 43.1k| case Opcode::I32X4MaxU: ------------------ | Branch (1105:7): [True: 0, False: 379k] ------------------ 1106| 43.1k| case Opcode::I8X16Shl: ------------------ | Branch (1106:7): [True: 0, False: 379k] ------------------ 1107| 43.1k| case Opcode::I16X8Shl: ------------------ | Branch (1107:7): [True: 0, False: 379k] ------------------ 1108| 43.1k| case Opcode::I32X4Shl: ------------------ | Branch (1108:7): [True: 0, False: 379k] ------------------ 1109| 43.1k| case Opcode::I64X2Shl: ------------------ | Branch (1109:7): [True: 0, False: 379k] ------------------ 1110| 43.1k| case Opcode::I8X16ShrS: ------------------ | Branch (1110:7): [True: 0, False: 379k] ------------------ 1111| 43.1k| case Opcode::I8X16ShrU: ------------------ | Branch (1111:7): [True: 0, False: 379k] ------------------ 1112| 43.1k| case Opcode::I16X8ShrS: ------------------ | Branch (1112:7): [True: 8, False: 379k] ------------------ 1113| 43.1k| case Opcode::I16X8ShrU: ------------------ | Branch (1113:7): [True: 0, False: 379k] ------------------ 1114| 43.1k| case Opcode::I32X4ShrS: ------------------ | Branch (1114:7): [True: 0, False: 379k] ------------------ 1115| 43.1k| case Opcode::I32X4ShrU: ------------------ | Branch (1115:7): [True: 20, False: 379k] ------------------ 1116| 43.1k| case Opcode::I64X2ShrS: ------------------ | Branch (1116:7): [True: 0, False: 379k] ------------------ 1117| 43.1k| case Opcode::I64X2ShrU: ------------------ | Branch (1117:7): [True: 0, False: 379k] ------------------ 1118| 43.1k| case Opcode::V128And: ------------------ | Branch (1118:7): [True: 0, False: 379k] ------------------ 1119| 43.1k| case Opcode::V128Or: ------------------ | Branch (1119:7): [True: 0, False: 379k] ------------------ 1120| 43.1k| case Opcode::V128Xor: ------------------ | Branch (1120:7): [True: 1, False: 379k] ------------------ 1121| 43.1k| case Opcode::F32X4Min: ------------------ | Branch (1121:7): [True: 7, False: 379k] ------------------ 1122| 43.3k| case Opcode::F32X4PMin: ------------------ | Branch (1122:7): [True: 119, False: 379k] ------------------ 1123| 43.3k| case Opcode::F64X2Min: ------------------ | Branch (1123:7): [True: 3, False: 379k] ------------------ 1124| 43.3k| case Opcode::F64X2PMin: ------------------ | Branch (1124:7): [True: 15, False: 379k] ------------------ 1125| 43.3k| case Opcode::F32X4Max: ------------------ | Branch (1125:7): [True: 2, False: 379k] ------------------ 1126| 43.3k| case Opcode::F32X4PMax: ------------------ | Branch (1126:7): [True: 0, False: 379k] ------------------ 1127| 43.3k| case Opcode::F64X2Max: ------------------ | Branch (1127:7): [True: 0, False: 379k] ------------------ 1128| 43.3k| case Opcode::F64X2PMax: ------------------ | Branch (1128:7): [True: 2, False: 379k] ------------------ 1129| 43.3k| case Opcode::F32X4Add: ------------------ | Branch (1129:7): [True: 0, False: 379k] ------------------ 1130| 43.3k| case Opcode::F64X2Add: ------------------ | Branch (1130:7): [True: 0, False: 379k] ------------------ 1131| 43.3k| case Opcode::F32X4Sub: ------------------ | Branch (1131:7): [True: 0, False: 379k] ------------------ 1132| 43.3k| case Opcode::F64X2Sub: ------------------ | Branch (1132:7): [True: 0, False: 379k] ------------------ 1133| 43.3k| case Opcode::F32X4Div: ------------------ | Branch (1133:7): [True: 0, False: 379k] ------------------ 1134| 43.3k| case Opcode::F64X2Div: ------------------ | Branch (1134:7): [True: 3, False: 379k] ------------------ 1135| 43.3k| case Opcode::F32X4Mul: ------------------ | Branch (1135:7): [True: 0, False: 379k] ------------------ 1136| 43.3k| case Opcode::F64X2Mul: ------------------ | Branch (1136:7): [True: 0, False: 379k] ------------------ 1137| 43.3k| case Opcode::I8X16Swizzle: ------------------ | Branch (1137:7): [True: 0, False: 379k] ------------------ 1138| 43.3k| case Opcode::I8X16NarrowI16X8S: ------------------ | Branch (1138:7): [True: 11, False: 379k] ------------------ 1139| 43.3k| case Opcode::I8X16NarrowI16X8U: ------------------ | Branch (1139:7): [True: 10, False: 379k] ------------------ 1140| 43.5k| case Opcode::I16X8NarrowI32X4S: ------------------ | Branch (1140:7): [True: 175, False: 379k] ------------------ 1141| 43.5k| case Opcode::I16X8NarrowI32X4U: ------------------ | Branch (1141:7): [True: 1, False: 379k] ------------------ 1142| 43.5k| case Opcode::V128Andnot: ------------------ | Branch (1142:7): [True: 56, False: 379k] ------------------ 1143| 43.5k| case Opcode::I8X16AvgrU: ------------------ | Branch (1143:7): [True: 5, False: 379k] ------------------ 1144| 43.5k| case Opcode::I16X8AvgrU: ------------------ | Branch (1144:7): [True: 0, False: 379k] ------------------ 1145| 43.6k| case Opcode::I16X8ExtmulLowI8X16S: ------------------ | Branch (1145:7): [True: 9, False: 379k] ------------------ 1146| 43.6k| case Opcode::I16X8ExtmulHighI8X16S: ------------------ | Branch (1146:7): [True: 12, False: 379k] ------------------ 1147| 43.6k| case Opcode::I16X8ExtmulLowI8X16U: ------------------ | Branch (1147:7): [True: 0, False: 379k] ------------------ 1148| 43.6k| case Opcode::I16X8ExtmulHighI8X16U: ------------------ | Branch (1148:7): [True: 2, False: 379k] ------------------ 1149| 43.6k| case Opcode::I32X4ExtmulLowI16X8S: ------------------ | Branch (1149:7): [True: 19, False: 379k] ------------------ 1150| 43.6k| case Opcode::I32X4ExtmulHighI16X8S: ------------------ | Branch (1150:7): [True: 0, False: 379k] ------------------ 1151| 43.6k| case Opcode::I32X4ExtmulLowI16X8U: ------------------ | Branch (1151:7): [True: 0, False: 379k] ------------------ 1152| 43.6k| case Opcode::I32X4ExtmulHighI16X8U: ------------------ | Branch (1152:7): [True: 0, False: 379k] ------------------ 1153| 43.9k| case Opcode::I64X2ExtmulLowI32X4S: ------------------ | Branch (1153:7): [True: 284, False: 379k] ------------------ 1154| 43.9k| case Opcode::I64X2ExtmulHighI32X4S: ------------------ | Branch (1154:7): [True: 0, False: 379k] ------------------ 1155| 43.9k| case Opcode::I64X2ExtmulLowI32X4U: ------------------ | Branch (1155:7): [True: 0, False: 379k] ------------------ 1156| 43.9k| case Opcode::I64X2ExtmulHighI32X4U: ------------------ | Branch (1156:7): [True: 0, False: 379k] ------------------ 1157| 43.9k| case Opcode::I16X8Q15mulrSatS: ------------------ | Branch (1157:7): [True: 0, False: 379k] ------------------ 1158| 43.9k| case Opcode::I32X4DotI16X8S: ------------------ | Branch (1158:7): [True: 0, False: 379k] ------------------ 1159| 43.9k| case Opcode::I8X16RelaxedSwizzle: ------------------ | Branch (1159:7): [True: 0, False: 379k] ------------------ 1160| 43.9k| case Opcode::F32X4RelaxedMin: ------------------ | Branch (1160:7): [True: 0, False: 379k] ------------------ 1161| 43.9k| case Opcode::F32X4RelaxedMax: ------------------ | Branch (1161:7): [True: 0, False: 379k] ------------------ 1162| 43.9k| case Opcode::F64X2RelaxedMin: ------------------ | Branch (1162:7): [True: 0, False: 379k] ------------------ 1163| 43.9k| case Opcode::F64X2RelaxedMax: ------------------ | Branch (1163:7): [True: 0, False: 379k] ------------------ 1164| 43.9k| case Opcode::I16X8RelaxedQ15mulrS: ------------------ | Branch (1164:7): [True: 0, False: 379k] ------------------ 1165| 43.9k| case Opcode::I16X8DotI8X16I7X16S: ------------------ | Branch (1165:7): [True: 0, False: 379k] ------------------ 1166| 43.9k| CALLBACK(OnBinaryExpr, opcode); ------------------ | | 61| 43.9k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 43.9k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 43.9k| do { \ | | | | | | 42| 43.9k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 11, False: 43.9k] | | | | | | ------------------ | | | | | | 43| 11| PrintError(__VA_ARGS__); \ | | | | | | 44| 11| return Result::Error; \ | | | | | | 45| 11| } \ | | | | | | 46| 43.9k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 43.9k| #member " callback failed") ------------------ 1167| 43.9k| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 43.9k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 43.9k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 43.9k| do { \ | | | | | | 42| 43.9k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 43.9k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 43.9k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1168| 43.9k| break; 1169| | 1170| 43.9k| case Opcode::I32Eq: ------------------ | Branch (1170:7): [True: 23, False: 379k] ------------------ 1171| 32| case Opcode::I32Ne: ------------------ | Branch (1171:7): [True: 9, False: 379k] ------------------ 1172| 38| case Opcode::I32LtS: ------------------ | Branch (1172:7): [True: 6, False: 379k] ------------------ 1173| 51| case Opcode::I32LeS: ------------------ | Branch (1173:7): [True: 13, False: 379k] ------------------ 1174| 161| case Opcode::I32LtU: ------------------ | Branch (1174:7): [True: 110, False: 379k] ------------------ 1175| 2.13k| case Opcode::I32LeU: ------------------ | Branch (1175:7): [True: 1.97k, False: 377k] ------------------ 1176| 2.14k| case Opcode::I32GtS: ------------------ | Branch (1176:7): [True: 8, False: 379k] ------------------ 1177| 2.18k| case Opcode::I32GeS: ------------------ | Branch (1177:7): [True: 47, False: 379k] ------------------ 1178| 2.31k| case Opcode::I32GtU: ------------------ | Branch (1178:7): [True: 127, False: 379k] ------------------ 1179| 2.45k| case Opcode::I32GeU: ------------------ | Branch (1179:7): [True: 144, False: 379k] ------------------ 1180| 2.46k| case Opcode::I64Eq: ------------------ | Branch (1180:7): [True: 4, False: 379k] ------------------ 1181| 2.50k| case Opcode::I64Ne: ------------------ | Branch (1181:7): [True: 46, False: 379k] ------------------ 1182| 2.51k| case Opcode::I64LtS: ------------------ | Branch (1182:7): [True: 2, False: 379k] ------------------ 1183| 2.57k| case Opcode::I64LeS: ------------------ | Branch (1183:7): [True: 67, False: 379k] ------------------ 1184| 2.58k| case Opcode::I64LtU: ------------------ | Branch (1184:7): [True: 4, False: 379k] ------------------ 1185| 2.58k| case Opcode::I64LeU: ------------------ | Branch (1185:7): [True: 0, False: 379k] ------------------ 1186| 2.60k| case Opcode::I64GtS: ------------------ | Branch (1186:7): [True: 21, False: 379k] ------------------ 1187| 2.65k| case Opcode::I64GeS: ------------------ | Branch (1187:7): [True: 56, False: 379k] ------------------ 1188| 2.91k| case Opcode::I64GtU: ------------------ | Branch (1188:7): [True: 256, False: 379k] ------------------ 1189| 2.93k| case Opcode::I64GeU: ------------------ | Branch (1189:7): [True: 16, False: 379k] ------------------ 1190| 2.96k| case Opcode::F32Eq: ------------------ | Branch (1190:7): [True: 32, False: 379k] ------------------ 1191| 2.96k| case Opcode::F32Ne: ------------------ | Branch (1191:7): [True: 1, False: 379k] ------------------ 1192| 3.05k| case Opcode::F32Lt: ------------------ | Branch (1192:7): [True: 89, False: 379k] ------------------ 1193| 3.05k| case Opcode::F32Le: ------------------ | Branch (1193:7): [True: 1, False: 379k] ------------------ 1194| 3.05k| case Opcode::F32Gt: ------------------ | Branch (1194:7): [True: 1, False: 379k] ------------------ 1195| 3.11k| case Opcode::F32Ge: ------------------ | Branch (1195:7): [True: 63, False: 379k] ------------------ 1196| 3.13k| case Opcode::F64Eq: ------------------ | Branch (1196:7): [True: 13, False: 379k] ------------------ 1197| 3.21k| case Opcode::F64Ne: ------------------ | Branch (1197:7): [True: 84, False: 379k] ------------------ 1198| 4.61k| case Opcode::F64Lt: ------------------ | Branch (1198:7): [True: 1.40k, False: 378k] ------------------ 1199| 4.61k| case Opcode::F64Le: ------------------ | Branch (1199:7): [True: 2, False: 379k] ------------------ 1200| 4.61k| case Opcode::F64Gt: ------------------ | Branch (1200:7): [True: 2, False: 379k] ------------------ 1201| 4.70k| case Opcode::F64Ge: ------------------ | Branch (1201:7): [True: 87, False: 379k] ------------------ 1202| 4.70k| case Opcode::I8X16Eq: ------------------ | Branch (1202:7): [True: 3, False: 379k] ------------------ 1203| 4.83k| case Opcode::I16X8Eq: ------------------ | Branch (1203:7): [True: 123, False: 379k] ------------------ 1204| 4.87k| case Opcode::I32X4Eq: ------------------ | Branch (1204:7): [True: 44, False: 379k] ------------------ 1205| 4.89k| case Opcode::I64X2Eq: ------------------ | Branch (1205:7): [True: 14, False: 379k] ------------------ 1206| 6.06k| case Opcode::F32X4Eq: ------------------ | Branch (1206:7): [True: 1.17k, False: 378k] ------------------ 1207| 6.06k| case Opcode::F64X2Eq: ------------------ | Branch (1207:7): [True: 0, False: 379k] ------------------ 1208| 6.07k| case Opcode::I8X16Ne: ------------------ | Branch (1208:7): [True: 1, False: 379k] ------------------ 1209| 6.07k| case Opcode::I16X8Ne: ------------------ | Branch (1209:7): [True: 0, False: 379k] ------------------ 1210| 6.12k| case Opcode::I32X4Ne: ------------------ | Branch (1210:7): [True: 50, False: 379k] ------------------ 1211| 6.12k| case Opcode::I64X2Ne: ------------------ | Branch (1211:7): [True: 4, False: 379k] ------------------ 1212| 6.12k| case Opcode::F32X4Ne: ------------------ | Branch (1212:7): [True: 0, False: 379k] ------------------ 1213| 6.12k| case Opcode::F64X2Ne: ------------------ | Branch (1213:7): [True: 0, False: 379k] ------------------ 1214| 6.12k| case Opcode::I8X16LtS: ------------------ | Branch (1214:7): [True: 1, False: 379k] ------------------ 1215| 6.34k| case Opcode::I8X16LtU: ------------------ | Branch (1215:7): [True: 219, False: 379k] ------------------ 1216| 6.39k| case Opcode::I16X8LtS: ------------------ | Branch (1216:7): [True: 52, False: 379k] ------------------ 1217| 6.74k| case Opcode::I16X8LtU: ------------------ | Branch (1217:7): [True: 346, False: 379k] ------------------ 1218| 7.18k| case Opcode::I32X4LtS: ------------------ | Branch (1218:7): [True: 438, False: 379k] ------------------ 1219| 7.57k| case Opcode::I32X4LtU: ------------------ | Branch (1219:7): [True: 395, False: 379k] ------------------ 1220| 7.61k| case Opcode::I64X2LtS: ------------------ | Branch (1220:7): [True: 42, False: 379k] ------------------ 1221| 7.61k| case Opcode::F32X4Lt: ------------------ | Branch (1221:7): [True: 0, False: 379k] ------------------ 1222| 7.74k| case Opcode::F64X2Lt: ------------------ | Branch (1222:7): [True: 131, False: 379k] ------------------ 1223| 8.93k| case Opcode::I8X16LeS: ------------------ | Branch (1223:7): [True: 1.18k, False: 378k] ------------------ 1224| 8.93k| case Opcode::I8X16LeU: ------------------ | Branch (1224:7): [True: 1, False: 379k] ------------------ 1225| 9.05k| case Opcode::I16X8LeS: ------------------ | Branch (1225:7): [True: 121, False: 379k] ------------------ 1226| 10.0k| case Opcode::I16X8LeU: ------------------ | Branch (1226:7): [True: 974, False: 378k] ------------------ 1227| 10.0k| case Opcode::I32X4LeS: ------------------ | Branch (1227:7): [True: 4, False: 379k] ------------------ 1228| 10.0k| case Opcode::I32X4LeU: ------------------ | Branch (1228:7): [True: 0, False: 379k] ------------------ 1229| 10.0k| case Opcode::I64X2LeS: ------------------ | Branch (1229:7): [True: 0, False: 379k] ------------------ 1230| 10.0k| case Opcode::F32X4Le: ------------------ | Branch (1230:7): [True: 0, False: 379k] ------------------ 1231| 10.0k| case Opcode::F64X2Le: ------------------ | Branch (1231:7): [True: 21, False: 379k] ------------------ 1232| 10.0k| case Opcode::I8X16GtS: ------------------ | Branch (1232:7): [True: 0, False: 379k] ------------------ 1233| 10.1k| case Opcode::I8X16GtU: ------------------ | Branch (1233:7): [True: 147, False: 379k] ------------------ 1234| 11.4k| case Opcode::I16X8GtS: ------------------ | Branch (1234:7): [True: 1.29k, False: 378k] ------------------ 1235| 11.6k| case Opcode::I16X8GtU: ------------------ | Branch (1235:7): [True: 195, False: 379k] ------------------ 1236| 11.6k| case Opcode::I32X4GtS: ------------------ | Branch (1236:7): [True: 1, False: 379k] ------------------ 1237| 11.6k| case Opcode::I32X4GtU: ------------------ | Branch (1237:7): [True: 0, False: 379k] ------------------ 1238| 11.6k| case Opcode::I64X2GtS: ------------------ | Branch (1238:7): [True: 1, False: 379k] ------------------ 1239| 11.6k| case Opcode::F32X4Gt: ------------------ | Branch (1239:7): [True: 0, False: 379k] ------------------ 1240| 11.6k| case Opcode::F64X2Gt: ------------------ | Branch (1240:7): [True: 1, False: 379k] ------------------ 1241| 11.6k| case Opcode::I8X16GeS: ------------------ | Branch (1241:7): [True: 0, False: 379k] ------------------ 1242| 11.8k| case Opcode::I8X16GeU: ------------------ | Branch (1242:7): [True: 160, False: 379k] ------------------ 1243| 11.9k| case Opcode::I16X8GeS: ------------------ | Branch (1243:7): [True: 63, False: 379k] ------------------ 1244| 11.9k| case Opcode::I16X8GeU: ------------------ | Branch (1244:7): [True: 55, False: 379k] ------------------ 1245| 12.0k| case Opcode::I32X4GeS: ------------------ | Branch (1245:7): [True: 81, False: 379k] ------------------ 1246| 12.0k| case Opcode::I32X4GeU: ------------------ | Branch (1246:7): [True: 20, False: 379k] ------------------ 1247| 12.0k| case Opcode::I64X2GeS: ------------------ | Branch (1247:7): [True: 0, False: 379k] ------------------ 1248| 12.0k| case Opcode::F32X4Ge: ------------------ | Branch (1248:7): [True: 0, False: 379k] ------------------ 1249| 12.0k| case Opcode::F64X2Ge: ------------------ | Branch (1249:7): [True: 0, False: 379k] ------------------ 1250| 12.0k| CALLBACK(OnCompareExpr, opcode); ------------------ | | 61| 12.0k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 12.0k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 12.0k| do { \ | | | | | | 42| 12.0k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 26, False: 12.0k] | | | | | | ------------------ | | | | | | 43| 26| PrintError(__VA_ARGS__); \ | | | | | | 44| 26| return Result::Error; \ | | | | | | 45| 26| } \ | | | | | | 46| 12.0k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 12.0k| #member " callback failed") ------------------ 1251| 12.0k| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 12.0k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 12.0k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 12.0k| do { \ | | | | | | 42| 12.0k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 12.0k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 12.0k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1252| 12.0k| break; 1253| | 1254| 12.0k| case Opcode::I32Clz: ------------------ | Branch (1254:7): [True: 5.97k, False: 373k] ------------------ 1255| 5.99k| case Opcode::I32Ctz: ------------------ | Branch (1255:7): [True: 27, False: 379k] ------------------ 1256| 6.98k| case Opcode::I32Popcnt: ------------------ | Branch (1256:7): [True: 990, False: 378k] ------------------ 1257| 6.99k| case Opcode::I64Clz: ------------------ | Branch (1257:7): [True: 4, False: 379k] ------------------ 1258| 7.36k| case Opcode::I64Ctz: ------------------ | Branch (1258:7): [True: 371, False: 379k] ------------------ 1259| 7.37k| case Opcode::I64Popcnt: ------------------ | Branch (1259:7): [True: 8, False: 379k] ------------------ 1260| 7.52k| case Opcode::F32Abs: ------------------ | Branch (1260:7): [True: 150, False: 379k] ------------------ 1261| 7.52k| case Opcode::F32Neg: ------------------ | Branch (1261:7): [True: 4, False: 379k] ------------------ 1262| 7.52k| case Opcode::F32Ceil: ------------------ | Branch (1262:7): [True: 2, False: 379k] ------------------ 1263| 7.52k| case Opcode::F32Floor: ------------------ | Branch (1263:7): [True: 3, False: 379k] ------------------ 1264| 10.3k| case Opcode::F32Trunc: ------------------ | Branch (1264:7): [True: 2.79k, False: 376k] ------------------ 1265| 10.3k| case Opcode::F32Nearest: ------------------ | Branch (1265:7): [True: 16, False: 379k] ------------------ 1266| 12.7k| case Opcode::F32Sqrt: ------------------ | Branch (1266:7): [True: 2.45k, False: 377k] ------------------ 1267| 13.0k| case Opcode::F64Abs: ------------------ | Branch (1267:7): [True: 261, False: 379k] ------------------ 1268| 13.9k| case Opcode::F64Neg: ------------------ | Branch (1268:7): [True: 896, False: 378k] ------------------ 1269| 14.1k| case Opcode::F64Ceil: ------------------ | Branch (1269:7): [True: 203, False: 379k] ------------------ 1270| 14.1k| case Opcode::F64Floor: ------------------ | Branch (1270:7): [True: 4, False: 379k] ------------------ 1271| 14.3k| case Opcode::F64Trunc: ------------------ | Branch (1271:7): [True: 152, False: 379k] ------------------ 1272| 14.3k| case Opcode::F64Nearest: ------------------ | Branch (1272:7): [True: 0, False: 379k] ------------------ 1273| 14.3k| case Opcode::F64Sqrt: ------------------ | Branch (1273:7): [True: 0, False: 379k] ------------------ 1274| 14.4k| case Opcode::I8X16Splat: ------------------ | Branch (1274:7): [True: 125, False: 379k] ------------------ 1275| 14.4k| case Opcode::I16X8Splat: ------------------ | Branch (1275:7): [True: 3, False: 379k] ------------------ 1276| 14.4k| case Opcode::I32X4Splat: ------------------ | Branch (1276:7): [True: 3, False: 379k] ------------------ 1277| 14.4k| case Opcode::I64X2Splat: ------------------ | Branch (1277:7): [True: 0, False: 379k] ------------------ 1278| 14.4k| case Opcode::F32X4Splat: ------------------ | Branch (1278:7): [True: 30, False: 379k] ------------------ 1279| 14.4k| case Opcode::F64X2Splat: ------------------ | Branch (1279:7): [True: 0, False: 379k] ------------------ 1280| 14.4k| case Opcode::I8X16Neg: ------------------ | Branch (1280:7): [True: 0, False: 379k] ------------------ 1281| 14.6k| case Opcode::I16X8Neg: ------------------ | Branch (1281:7): [True: 219, False: 379k] ------------------ 1282| 14.6k| case Opcode::I32X4Neg: ------------------ | Branch (1282:7): [True: 0, False: 379k] ------------------ 1283| 15.6k| case Opcode::I64X2Neg: ------------------ | Branch (1283:7): [True: 960, False: 378k] ------------------ 1284| 15.6k| case Opcode::V128Not: ------------------ | Branch (1284:7): [True: 0, False: 379k] ------------------ 1285| 15.7k| case Opcode::V128AnyTrue: ------------------ | Branch (1285:7): [True: 51, False: 379k] ------------------ 1286| 15.7k| case Opcode::I8X16Bitmask: ------------------ | Branch (1286:7): [True: 0, False: 379k] ------------------ 1287| 15.7k| case Opcode::I16X8Bitmask: ------------------ | Branch (1287:7): [True: 1, False: 379k] ------------------ 1288| 15.7k| case Opcode::I32X4Bitmask: ------------------ | Branch (1288:7): [True: 0, False: 379k] ------------------ 1289| 15.8k| case Opcode::I64X2Bitmask: ------------------ | Branch (1289:7): [True: 113, False: 379k] ------------------ 1290| 15.8k| case Opcode::I8X16AllTrue: ------------------ | Branch (1290:7): [True: 9, False: 379k] ------------------ 1291| 15.8k| case Opcode::I16X8AllTrue: ------------------ | Branch (1291:7): [True: 8, False: 379k] ------------------ 1292| 15.8k| case Opcode::I32X4AllTrue: ------------------ | Branch (1292:7): [True: 8, False: 379k] ------------------ 1293| 15.8k| case Opcode::I64X2AllTrue: ------------------ | Branch (1293:7): [True: 0, False: 379k] ------------------ 1294| 15.8k| case Opcode::F32X4Ceil: ------------------ | Branch (1294:7): [True: 2, False: 379k] ------------------ 1295| 15.8k| case Opcode::F64X2Ceil: ------------------ | Branch (1295:7): [True: 37, False: 379k] ------------------ 1296| 15.8k| case Opcode::F32X4Floor: ------------------ | Branch (1296:7): [True: 0, False: 379k] ------------------ 1297| 15.9k| case Opcode::F64X2Floor: ------------------ | Branch (1297:7): [True: 24, False: 379k] ------------------ 1298| 15.9k| case Opcode::F32X4Trunc: ------------------ | Branch (1298:7): [True: 27, False: 379k] ------------------ 1299| 16.0k| case Opcode::F64X2Trunc: ------------------ | Branch (1299:7): [True: 164, False: 379k] ------------------ 1300| 16.1k| case Opcode::F32X4Nearest: ------------------ | Branch (1300:7): [True: 17, False: 379k] ------------------ 1301| 16.1k| case Opcode::F64X2Nearest: ------------------ | Branch (1301:7): [True: 23, False: 379k] ------------------ 1302| 16.1k| case Opcode::F32X4Neg: ------------------ | Branch (1302:7): [True: 1, False: 379k] ------------------ 1303| 16.1k| case Opcode::F64X2Neg: ------------------ | Branch (1303:7): [True: 0, False: 379k] ------------------ 1304| 16.1k| case Opcode::F32X4Abs: ------------------ | Branch (1304:7): [True: 2, False: 379k] ------------------ 1305| 16.1k| case Opcode::F64X2Abs: ------------------ | Branch (1305:7): [True: 1, False: 379k] ------------------ 1306| 16.1k| case Opcode::F32X4Sqrt: ------------------ | Branch (1306:7): [True: 0, False: 379k] ------------------ 1307| 16.1k| case Opcode::F64X2Sqrt: ------------------ | Branch (1307:7): [True: 0, False: 379k] ------------------ 1308| 18.0k| case Opcode::I16X8ExtendLowI8X16S: ------------------ | Branch (1308:7): [True: 1.91k, False: 377k] ------------------ 1309| 18.0k| case Opcode::I16X8ExtendHighI8X16S: ------------------ | Branch (1309:7): [True: 26, False: 379k] ------------------ 1310| 18.0k| case Opcode::I16X8ExtendLowI8X16U: ------------------ | Branch (1310:7): [True: 11, False: 379k] ------------------ 1311| 18.1k| case Opcode::I16X8ExtendHighI8X16U: ------------------ | Branch (1311:7): [True: 28, False: 379k] ------------------ 1312| 18.1k| case Opcode::I32X4ExtendLowI16X8S: ------------------ | Branch (1312:7): [True: 5, False: 379k] ------------------ 1313| 18.3k| case Opcode::I32X4ExtendHighI16X8S: ------------------ | Branch (1313:7): [True: 184, False: 379k] ------------------ 1314| 18.3k| case Opcode::I32X4ExtendLowI16X8U: ------------------ | Branch (1314:7): [True: 1, False: 379k] ------------------ 1315| 18.3k| case Opcode::I32X4ExtendHighI16X8U: ------------------ | Branch (1315:7): [True: 8, False: 379k] ------------------ 1316| 18.3k| case Opcode::I64X2ExtendLowI32X4S: ------------------ | Branch (1316:7): [True: 0, False: 379k] ------------------ 1317| 18.3k| case Opcode::I64X2ExtendHighI32X4S: ------------------ | Branch (1317:7): [True: 0, False: 379k] ------------------ 1318| 18.3k| case Opcode::I64X2ExtendLowI32X4U: ------------------ | Branch (1318:7): [True: 0, False: 379k] ------------------ 1319| 18.3k| case Opcode::I64X2ExtendHighI32X4U: ------------------ | Branch (1319:7): [True: 0, False: 379k] ------------------ 1320| 21.6k| case Opcode::I8X16Abs: ------------------ | Branch (1320:7): [True: 3.31k, False: 376k] ------------------ 1321| 21.6k| case Opcode::I16X8Abs: ------------------ | Branch (1321:7): [True: 0, False: 379k] ------------------ 1322| 21.6k| case Opcode::I32X4Abs: ------------------ | Branch (1322:7): [True: 0, False: 379k] ------------------ 1323| 21.6k| case Opcode::I64X2Abs: ------------------ | Branch (1323:7): [True: 1, False: 379k] ------------------ 1324| 21.6k| case Opcode::I8X16Popcnt: ------------------ | Branch (1324:7): [True: 9, False: 379k] ------------------ 1325| 28.2k| case Opcode::I16X8ExtaddPairwiseI8X16S: ------------------ | Branch (1325:7): [True: 6.64k, False: 373k] ------------------ 1326| 28.3k| case Opcode::I16X8ExtaddPairwiseI8X16U: ------------------ | Branch (1326:7): [True: 26, False: 379k] ------------------ 1327| 28.3k| case Opcode::I32X4ExtaddPairwiseI16X8S: ------------------ | Branch (1327:7): [True: 26, False: 379k] ------------------ 1328| 28.4k| case Opcode::I32X4ExtaddPairwiseI16X8U: ------------------ | Branch (1328:7): [True: 68, False: 379k] ------------------ 1329| 28.4k| case Opcode::I32X4RelaxedTruncF32X4S: ------------------ | Branch (1329:7): [True: 0, False: 379k] ------------------ 1330| 28.4k| case Opcode::I32X4RelaxedTruncF32X4U: ------------------ | Branch (1330:7): [True: 0, False: 379k] ------------------ 1331| 28.4k| case Opcode::I32X4RelaxedTruncF64X2SZero: ------------------ | Branch (1331:7): [True: 0, False: 379k] ------------------ 1332| 28.4k| case Opcode::I32X4RelaxedTruncF64X2UZero: ------------------ | Branch (1332:7): [True: 0, False: 379k] ------------------ 1333| 28.4k| CALLBACK(OnUnaryExpr, opcode); ------------------ | | 61| 28.4k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 28.4k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 28.4k| do { \ | | | | | | 42| 28.4k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 18, False: 28.3k] | | | | | | ------------------ | | | | | | 43| 18| PrintError(__VA_ARGS__); \ | | | | | | 44| 18| return Result::Error; \ | | | | | | 45| 18| } \ | | | | | | 46| 28.4k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 28.4k| #member " callback failed") ------------------ 1334| 28.3k| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 28.3k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 28.3k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 28.3k| do { \ | | | | | | 42| 28.3k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 28.3k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 28.3k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1335| 28.3k| break; 1336| | 1337| 28.3k| case Opcode::V128BitSelect: ------------------ | Branch (1337:7): [True: 0, False: 379k] ------------------ 1338| 0| case Opcode::F32X4RelaxedMadd: ------------------ | Branch (1338:7): [True: 0, False: 379k] ------------------ 1339| 0| case Opcode::F32X4RelaxedNmadd: ------------------ | Branch (1339:7): [True: 0, False: 379k] ------------------ 1340| 0| case Opcode::F64X2RelaxedMadd: ------------------ | Branch (1340:7): [True: 0, False: 379k] ------------------ 1341| 0| case Opcode::F64X2RelaxedNmadd: ------------------ | Branch (1341:7): [True: 0, False: 379k] ------------------ 1342| 0| case Opcode::I8X16RelaxedLaneSelect: ------------------ | Branch (1342:7): [True: 0, False: 379k] ------------------ 1343| 0| case Opcode::I16X8RelaxedLaneSelect: ------------------ | Branch (1343:7): [True: 0, False: 379k] ------------------ 1344| 0| case Opcode::I32X4RelaxedLaneSelect: ------------------ | Branch (1344:7): [True: 0, False: 379k] ------------------ 1345| 0| case Opcode::I64X2RelaxedLaneSelect: ------------------ | Branch (1345:7): [True: 0, False: 379k] ------------------ 1346| 0| case Opcode::I32X4DotI8X16I7X16AddS: ------------------ | Branch (1346:7): [True: 0, False: 379k] ------------------ 1347| 0| CALLBACK(OnTernaryExpr, opcode); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1348| 0| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 0| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1349| 0| break; 1350| | 1351| 4| case Opcode::I8X16ExtractLaneS: ------------------ | Branch (1351:7): [True: 4, False: 379k] ------------------ 1352| 4| case Opcode::I8X16ExtractLaneU: ------------------ | Branch (1352:7): [True: 0, False: 379k] ------------------ 1353| 5| case Opcode::I16X8ExtractLaneS: ------------------ | Branch (1353:7): [True: 1, False: 379k] ------------------ 1354| 186| case Opcode::I16X8ExtractLaneU: ------------------ | Branch (1354:7): [True: 181, False: 379k] ------------------ 1355| 186| case Opcode::I32X4ExtractLane: ------------------ | Branch (1355:7): [True: 0, False: 379k] ------------------ 1356| 439| case Opcode::I64X2ExtractLane: ------------------ | Branch (1356:7): [True: 253, False: 379k] ------------------ 1357| 439| case Opcode::F32X4ExtractLane: ------------------ | Branch (1357:7): [True: 0, False: 379k] ------------------ 1358| 644| case Opcode::F64X2ExtractLane: ------------------ | Branch (1358:7): [True: 205, False: 379k] ------------------ 1359| 736| case Opcode::I8X16ReplaceLane: ------------------ | Branch (1359:7): [True: 92, False: 379k] ------------------ 1360| 1.02k| case Opcode::I16X8ReplaceLane: ------------------ | Branch (1360:7): [True: 284, False: 379k] ------------------ 1361| 1.02k| case Opcode::I32X4ReplaceLane: ------------------ | Branch (1361:7): [True: 0, False: 379k] ------------------ 1362| 1.02k| case Opcode::I64X2ReplaceLane: ------------------ | Branch (1362:7): [True: 0, False: 379k] ------------------ 1363| 1.02k| case Opcode::F32X4ReplaceLane: ------------------ | Branch (1363:7): [True: 5, False: 379k] ------------------ 1364| 1.02k| case Opcode::F64X2ReplaceLane: { ------------------ | Branch (1364:7): [True: 0, False: 379k] ------------------ 1365| 1.02k| uint8_t lane_val; 1366| 1.02k| CHECK_RESULT(ReadU8(&lane_val, "Lane idx")); ------------------ | | 55| 1.02k| do { \ | | 56| 1.02k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.02k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.02k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1367| 1.02k| CALLBACK(OnSimdLaneOpExpr, opcode, lane_val); ------------------ | | 61| 1.02k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.02k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.02k| do { \ | | | | | | 42| 1.02k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 3, False: 1.02k] | | | | | | ------------------ | | | | | | 43| 3| PrintError(__VA_ARGS__); \ | | | | | | 44| 3| return Result::Error; \ | | | | | | 45| 3| } \ | | | | | | 46| 1.02k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.02k| #member " callback failed") ------------------ 1368| 1.02k| CALLBACK(OnOpcodeUint64, lane_val); ------------------ | | 61| 1.02k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.02k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.02k| do { \ | | | | | | 42| 1.02k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1.02k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1.02k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.02k| #member " callback failed") ------------------ 1369| 1.02k| break; 1370| 1.02k| } 1371| | 1372| 1.02k| case Opcode::I8X16Shuffle: { ------------------ | Branch (1372:7): [True: 4, False: 379k] ------------------ 1373| 4| v128 value; 1374| 4| CHECK_RESULT(ReadV128(&value, "Lane idx [16]")); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1375| 4| CALLBACK(OnSimdShuffleOpExpr, opcode, value); ------------------ | | 61| 4| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 4|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 4| do { \ | | | | | | 42| 4| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 43| 4| PrintError(__VA_ARGS__); \ | | | | | | 44| 4| return Result::Error; \ | | | | | | 45| 4| } \ | | | | | | 46| 4| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 4| #member " callback failed") ------------------ 1376| 0| CALLBACK(OnOpcodeV128, value); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1377| 0| break; 1378| 0| } 1379| | 1380| 27| case Opcode::V128Load8Splat: ------------------ | Branch (1380:7): [True: 27, False: 379k] ------------------ 1381| 51| case Opcode::V128Load16Splat: ------------------ | Branch (1381:7): [True: 24, False: 379k] ------------------ 1382| 385| case Opcode::V128Load32Splat: ------------------ | Branch (1382:7): [True: 334, False: 379k] ------------------ 1383| 396| case Opcode::V128Load64Splat: { ------------------ | Branch (1383:7): [True: 11, False: 379k] ------------------ 1384| 396| Address alignment_log2; 1385| 396| Index memidx; 1386| 396| Address offset; 1387| 396| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 396| do { \ | | 56| 396| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 396] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 396| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1388| 396| "load alignment", "load memidx", 1389| 396| "load offset")); 1390| 396| CALLBACK(OnLoadSplatExpr, opcode, memidx, alignment_log2, offset); ------------------ | | 61| 396| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 396|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 396| do { \ | | | | | | 42| 396| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 396] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 396| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 396| #member " callback failed") ------------------ 1391| 396| CHECK_RESULT(CallbackMemLocation(&alignment_log2, &memidx, &offset)); ------------------ | | 55| 396| do { \ | | 56| 396| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 396] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 396| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1392| 396| break; 1393| 396| } 1394| 396| case Opcode::V128Load8Lane: ------------------ | Branch (1394:7): [True: 108, False: 379k] ------------------ 1395| 137| case Opcode::V128Load16Lane: ------------------ | Branch (1395:7): [True: 29, False: 379k] ------------------ 1396| 170| case Opcode::V128Load32Lane: ------------------ | Branch (1396:7): [True: 33, False: 379k] ------------------ 1397| 170| case Opcode::V128Load64Lane: { ------------------ | Branch (1397:7): [True: 0, False: 379k] ------------------ 1398| 170| Address alignment_log2; 1399| 170| Index memidx; 1400| 170| Address offset; 1401| 170| uint8_t lane_val; 1402| 170| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 170| do { \ | | 56| 170| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 169] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 170| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1403| 170| "load alignment", "load memidx", 1404| 170| "load offset", &lane_val)); 1405| 169| CALLBACK(OnSimdLoadLaneExpr, opcode, memidx, alignment_log2, offset, ------------------ | | 61| 169| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 169|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 169| do { \ | | | | | | 42| 169| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 1, False: 168] | | | | | | ------------------ | | | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | | | 44| 1| return Result::Error; \ | | | | | | 45| 1| } \ | | | | | | 46| 169| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 169| #member " callback failed") ------------------ 1406| 168| lane_val); 1407| 168| CHECK_RESULT( ------------------ | | 55| 168| do { \ | | 56| 168| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 168] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 168| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1408| 168| CallbackMemLocation(&alignment_log2, &memidx, &offset, &lane_val)); 1409| 168| break; 1410| 168| } 1411| 168| case Opcode::V128Store8Lane: ------------------ | Branch (1411:7): [True: 0, False: 379k] ------------------ 1412| 176| case Opcode::V128Store16Lane: ------------------ | Branch (1412:7): [True: 176, False: 379k] ------------------ 1413| 176| case Opcode::V128Store32Lane: ------------------ | Branch (1413:7): [True: 0, False: 379k] ------------------ 1414| 201| case Opcode::V128Store64Lane: { ------------------ | Branch (1414:7): [True: 25, False: 379k] ------------------ 1415| 201| Address alignment_log2; 1416| 201| Index memidx; 1417| 201| Address offset; 1418| 201| uint8_t lane_val; 1419| 201| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 201| do { \ | | 56| 201| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 201] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 201| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1420| 201| "store alignment", "store memidx", 1421| 201| "store offset", &lane_val)); 1422| 201| CALLBACK(OnSimdStoreLaneExpr, opcode, memidx, alignment_log2, offset, ------------------ | | 61| 201| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 201|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 201| do { \ | | | | | | 42| 201| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 8, False: 193] | | | | | | ------------------ | | | | | | 43| 8| PrintError(__VA_ARGS__); \ | | | | | | 44| 8| return Result::Error; \ | | | | | | 45| 8| } \ | | | | | | 46| 201| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 201| #member " callback failed") ------------------ 1423| 193| lane_val); 1424| 193| CHECK_RESULT( ------------------ | | 55| 193| do { \ | | 56| 193| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 193] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 193| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1425| 193| CallbackMemLocation(&alignment_log2, &memidx, &offset, &lane_val)); 1426| 193| break; 1427| 193| } 1428| 440| case Opcode::V128Load32Zero: ------------------ | Branch (1428:7): [True: 440, False: 379k] ------------------ 1429| 444| case Opcode::V128Load64Zero: { ------------------ | Branch (1429:7): [True: 4, False: 379k] ------------------ 1430| 444| Address alignment_log2; 1431| 444| Index memidx; 1432| 444| Address offset; 1433| 444| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 444| do { \ | | 56| 444| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 444] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 444| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1434| 444| "load alignment", "load memidx", 1435| 444| "load offset")); 1436| 444| CALLBACK(OnLoadZeroExpr, opcode, memidx, alignment_log2, offset); ------------------ | | 61| 444| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 444|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 444| do { \ | | | | | | 42| 444| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 444] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 444| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 444| #member " callback failed") ------------------ 1437| 444| CHECK_RESULT(CallbackMemLocation(&alignment_log2, &memidx, &offset)); ------------------ | | 55| 444| do { \ | | 56| 444| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 444] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 444| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1438| 444| break; 1439| 444| } 1440| 444| case Opcode::I32TruncF32S: ------------------ | Branch (1440:7): [True: 95, False: 379k] ------------------ 1441| 144| case Opcode::I32TruncF64S: ------------------ | Branch (1441:7): [True: 49, False: 379k] ------------------ 1442| 144| case Opcode::I32TruncF32U: ------------------ | Branch (1442:7): [True: 0, False: 379k] ------------------ 1443| 146| case Opcode::I32TruncF64U: ------------------ | Branch (1443:7): [True: 2, False: 379k] ------------------ 1444| 161| case Opcode::I32WrapI64: ------------------ | Branch (1444:7): [True: 15, False: 379k] ------------------ 1445| 162| case Opcode::I64TruncF32S: ------------------ | Branch (1445:7): [True: 1, False: 379k] ------------------ 1446| 164| case Opcode::I64TruncF64S: ------------------ | Branch (1446:7): [True: 2, False: 379k] ------------------ 1447| 170| case Opcode::I64TruncF32U: ------------------ | Branch (1447:7): [True: 6, False: 379k] ------------------ 1448| 175| case Opcode::I64TruncF64U: ------------------ | Branch (1448:7): [True: 5, False: 379k] ------------------ 1449| 175| case Opcode::I64ExtendI32S: ------------------ | Branch (1449:7): [True: 0, False: 379k] ------------------ 1450| 264| case Opcode::I64ExtendI32U: ------------------ | Branch (1450:7): [True: 89, False: 379k] ------------------ 1451| 425| case Opcode::F32ConvertI32S: ------------------ | Branch (1451:7): [True: 161, False: 379k] ------------------ 1452| 556| case Opcode::F32ConvertI32U: ------------------ | Branch (1452:7): [True: 131, False: 379k] ------------------ 1453| 579| case Opcode::F32ConvertI64S: ------------------ | Branch (1453:7): [True: 23, False: 379k] ------------------ 1454| 1.37k| case Opcode::F32ConvertI64U: ------------------ | Branch (1454:7): [True: 792, False: 378k] ------------------ 1455| 1.37k| case Opcode::F32DemoteF64: ------------------ | Branch (1455:7): [True: 6, False: 379k] ------------------ 1456| 1.76k| case Opcode::F32ReinterpretI32: ------------------ | Branch (1456:7): [True: 392, False: 379k] ------------------ 1457| 2.01k| case Opcode::F64ConvertI32S: ------------------ | Branch (1457:7): [True: 249, False: 379k] ------------------ 1458| 2.02k| case Opcode::F64ConvertI32U: ------------------ | Branch (1458:7): [True: 2, False: 379k] ------------------ 1459| 2.02k| case Opcode::F64ConvertI64S: ------------------ | Branch (1459:7): [True: 0, False: 379k] ------------------ 1460| 2.02k| case Opcode::F64ConvertI64U: ------------------ | Branch (1460:7): [True: 1, False: 379k] ------------------ 1461| 2.02k| case Opcode::F64PromoteF32: ------------------ | Branch (1461:7): [True: 1, False: 379k] ------------------ 1462| 2.12k| case Opcode::F64ReinterpretI64: ------------------ | Branch (1462:7): [True: 102, False: 379k] ------------------ 1463| 2.24k| case Opcode::I32ReinterpretF32: ------------------ | Branch (1463:7): [True: 122, False: 379k] ------------------ 1464| 2.31k| case Opcode::I64ReinterpretF64: ------------------ | Branch (1464:7): [True: 67, False: 379k] ------------------ 1465| 2.36k| case Opcode::I32Eqz: ------------------ | Branch (1465:7): [True: 55, False: 379k] ------------------ 1466| 2.46k| case Opcode::I64Eqz: ------------------ | Branch (1466:7): [True: 93, False: 379k] ------------------ 1467| 3.14k| case Opcode::F32X4ConvertI32X4S: ------------------ | Branch (1467:7): [True: 681, False: 379k] ------------------ 1468| 3.16k| case Opcode::F32X4ConvertI32X4U: ------------------ | Branch (1468:7): [True: 25, False: 379k] ------------------ 1469| 3.19k| case Opcode::I32X4TruncSatF32X4S: ------------------ | Branch (1469:7): [True: 30, False: 379k] ------------------ 1470| 3.23k| case Opcode::I32X4TruncSatF32X4U: ------------------ | Branch (1470:7): [True: 35, False: 379k] ------------------ 1471| 3.23k| case Opcode::F32X4DemoteF64X2Zero: ------------------ | Branch (1471:7): [True: 1, False: 379k] ------------------ 1472| 3.25k| case Opcode::F64X2PromoteLowF32X4: ------------------ | Branch (1472:7): [True: 19, False: 379k] ------------------ 1473| 17.0k| case Opcode::I32X4TruncSatF64X2SZero: ------------------ | Branch (1473:7): [True: 13.7k, False: 365k] ------------------ 1474| 17.0k| case Opcode::I32X4TruncSatF64X2UZero: ------------------ | Branch (1474:7): [True: 30, False: 379k] ------------------ 1475| 17.0k| case Opcode::F64X2ConvertLowI32X4S: ------------------ | Branch (1475:7): [True: 42, False: 379k] ------------------ 1476| 17.4k| case Opcode::F64X2ConvertLowI32X4U: ------------------ | Branch (1476:7): [True: 356, False: 379k] ------------------ 1477| 17.4k| CALLBACK(OnConvertExpr, opcode); ------------------ | | 61| 17.4k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 17.4k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 17.4k| do { \ | | | | | | 42| 17.4k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 4, False: 17.4k] | | | | | | ------------------ | | | | | | 43| 4| PrintError(__VA_ARGS__); \ | | | | | | 44| 4| return Result::Error; \ | | | | | | 45| 4| } \ | | | | | | 46| 17.4k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 17.4k| #member " callback failed") ------------------ 1478| 17.4k| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 17.4k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 17.4k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 17.4k| do { \ | | | | | | 42| 17.4k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 17.4k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 17.4k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1479| 17.4k| break; 1480| | 1481| 17.4k| case Opcode::Try: { ------------------ | Branch (1481:7): [True: 1, False: 379k] ------------------ 1482| 1| nested_blocks.push(opcode); 1483| 1| Type sig_type; 1484| 1| CHECK_RESULT(ReadType(&sig_type, "try signature type")); ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1485| 1| ERROR_UNLESS(IsBlockType(sig_type), ------------------ | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 1| do { \ | | | | 42| 1| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 1] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 1| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1486| 1| "expected valid block signature type"); 1487| 1| CALLBACK(OnTryExpr, sig_type); ------------------ | | 61| 1| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1| do { \ | | | | | | 42| 1| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | | | 44| 1| return Result::Error; \ | | | | | | 45| 1| } \ | | | | | | 46| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1| #member " callback failed") ------------------ 1488| 0| CALLBACK(OnOpcodeBlockSig, sig_type); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1489| 0| break; 1490| 0| } 1491| | 1492| 4| case Opcode::Catch: { ------------------ | Branch (1492:7): [True: 4, False: 379k] ------------------ 1493| 4| Index index; 1494| 4| CHECK_RESULT(ReadIndex(&index, "tag index")); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1495| 4| CALLBACK(OnCatchExpr, index); ------------------ | | 61| 4| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 4|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 4| do { \ | | | | | | 42| 4| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 43| 4| PrintError(__VA_ARGS__); \ | | | | | | 44| 4| return Result::Error; \ | | | | | | 45| 4| } \ | | | | | | 46| 4| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 4| #member " callback failed") ------------------ 1496| 0| CALLBACK(OnOpcodeIndex, index); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1497| 0| break; 1498| 0| } 1499| | 1500| 0| case Opcode::CatchAll: { ------------------ | Branch (1500:7): [True: 0, False: 379k] ------------------ 1501| 0| CALLBACK(OnCatchAllExpr); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1502| 0| CALLBACK(OnOpcodeBare); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1503| 0| break; 1504| 0| } 1505| | 1506| 1| case Opcode::Delegate: { ------------------ | Branch (1506:7): [True: 1, False: 379k] ------------------ 1507| 1| ERROR_IF(nested_blocks.empty() || (nested_blocks.top() != Opcode::Try), ------------------ | | 41| 1| do { \ | | 42| 2| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 1, False: 0] | | | Branch (42:9): [True: 0, False: 0] | | ------------------ | | 43| 1| PrintError(__VA_ARGS__); \ | | 44| 1| return Result::Error; \ | | 45| 1| } \ | | 46| 1| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 1508| 1| "delegate outside try block"); 1509| 0| nested_blocks.pop(); 1510| 0| Index index; 1511| 0| CHECK_RESULT(ReadIndex(&index, "depth")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1512| 0| CALLBACK(OnDelegateExpr, index); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1513| 0| CALLBACK(OnOpcodeIndex, index); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1514| 0| break; 1515| 0| } 1516| | 1517| 4| case Opcode::Rethrow: { ------------------ | Branch (1517:7): [True: 4, False: 379k] ------------------ 1518| 4| Index depth; 1519| 4| CHECK_RESULT(ReadIndex(&depth, "catch depth")); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1520| 4| CALLBACK(OnRethrowExpr, depth); ------------------ | | 61| 4| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 4|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 4| do { \ | | | | | | 42| 4| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 43| 4| PrintError(__VA_ARGS__); \ | | | | | | 44| 4| return Result::Error; \ | | | | | | 45| 4| } \ | | | | | | 46| 4| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 4| #member " callback failed") ------------------ 1521| 0| CALLBACK(OnOpcodeIndex, depth); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1522| 0| break; 1523| 0| } 1524| | 1525| 1| case Opcode::Throw: { ------------------ | Branch (1525:7): [True: 1, False: 379k] ------------------ 1526| 1| Index index; 1527| 1| CHECK_RESULT(ReadIndex(&index, "tag index")); ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1528| 1| CALLBACK(OnThrowExpr, index); ------------------ | | 61| 1| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1| do { \ | | | | | | 42| 1| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | | | 44| 1| return Result::Error; \ | | | | | | 45| 1| } \ | | | | | | 46| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1| #member " callback failed") ------------------ 1529| 0| CALLBACK(OnOpcodeIndex, index); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1530| 0| break; 1531| 0| } 1532| | 1533| 4.93k| case Opcode::I32Extend8S: ------------------ | Branch (1533:7): [True: 4.93k, False: 374k] ------------------ 1534| 5.06k| case Opcode::I32Extend16S: ------------------ | Branch (1534:7): [True: 135, False: 379k] ------------------ 1535| 5.07k| case Opcode::I64Extend8S: ------------------ | Branch (1535:7): [True: 4, False: 379k] ------------------ 1536| 5.07k| case Opcode::I64Extend16S: ------------------ | Branch (1536:7): [True: 0, False: 379k] ------------------ 1537| 5.08k| case Opcode::I64Extend32S: ------------------ | Branch (1537:7): [True: 11, False: 379k] ------------------ 1538| 5.08k| CALLBACK(OnUnaryExpr, opcode); ------------------ | | 61| 5.08k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 5.08k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 5.08k| do { \ | | | | | | 42| 5.08k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 1, False: 5.08k] | | | | | | ------------------ | | | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | | | 44| 1| return Result::Error; \ | | | | | | 45| 1| } \ | | | | | | 46| 5.08k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 5.08k| #member " callback failed") ------------------ 1539| 5.08k| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 5.08k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 5.08k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 5.08k| do { \ | | | | | | 42| 5.08k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 5.08k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 5.08k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1540| 5.08k| break; 1541| | 1542| 5.08k| case Opcode::I32TruncSatF32S: ------------------ | Branch (1542:7): [True: 226, False: 379k] ------------------ 1543| 2.13k| case Opcode::I32TruncSatF32U: ------------------ | Branch (1543:7): [True: 1.91k, False: 377k] ------------------ 1544| 2.13k| case Opcode::I32TruncSatF64S: ------------------ | Branch (1544:7): [True: 0, False: 379k] ------------------ 1545| 2.13k| case Opcode::I32TruncSatF64U: ------------------ | Branch (1545:7): [True: 0, False: 379k] ------------------ 1546| 2.13k| case Opcode::I64TruncSatF32S: ------------------ | Branch (1546:7): [True: 0, False: 379k] ------------------ 1547| 2.23k| case Opcode::I64TruncSatF32U: ------------------ | Branch (1547:7): [True: 102, False: 379k] ------------------ 1548| 2.39k| case Opcode::I64TruncSatF64S: ------------------ | Branch (1548:7): [True: 160, False: 379k] ------------------ 1549| 2.40k| case Opcode::I64TruncSatF64U: ------------------ | Branch (1549:7): [True: 4, False: 379k] ------------------ 1550| 2.40k| CALLBACK(OnConvertExpr, opcode); ------------------ | | 61| 2.40k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2.40k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.40k| do { \ | | | | | | 42| 2.40k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 2, False: 2.40k] | | | | | | ------------------ | | | | | | 43| 2| PrintError(__VA_ARGS__); \ | | | | | | 44| 2| return Result::Error; \ | | | | | | 45| 2| } \ | | | | | | 46| 2.40k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2.40k| #member " callback failed") ------------------ 1551| 2.40k| CALLBACK0(OnOpcodeBare); ------------------ | | 58| 2.40k| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 2.40k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.40k| do { \ | | | | | | 42| 2.40k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2.40k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2.40k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1552| 2.40k| break; 1553| | 1554| 2.40k| case Opcode::MemoryAtomicNotify: { ------------------ | Branch (1554:7): [True: 1, False: 379k] ------------------ 1555| 1| Address alignment_log2; 1556| 1| Index memidx; 1557| 1| Address offset; 1558| 1| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1559| 1| "notify alignment", "notify memidx", 1560| 1| "notify offset")); 1561| 1| CALLBACK(OnAtomicNotifyExpr, opcode, memidx, alignment_log2, offset); ------------------ | | 61| 1| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1| do { \ | | | | | | 42| 1| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | | | 44| 1| return Result::Error; \ | | | | | | 45| 1| } \ | | | | | | 46| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1| #member " callback failed") ------------------ 1562| 0| CHECK_RESULT(CallbackMemLocation(&alignment_log2, &memidx, &offset)); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1563| 0| break; 1564| 0| } 1565| | 1566| 0| case Opcode::MemoryAtomicWait32: ------------------ | Branch (1566:7): [True: 0, False: 379k] ------------------ 1567| 0| case Opcode::MemoryAtomicWait64: { ------------------ | Branch (1567:7): [True: 0, False: 379k] ------------------ 1568| 0| Address alignment_log2; 1569| 0| Index memidx; 1570| 0| Address offset; 1571| 0| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1572| 0| "wait alignment", "wait memidx", 1573| 0| "wait offset")); 1574| 0| CALLBACK(OnAtomicWaitExpr, opcode, memidx, alignment_log2, offset); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1575| 0| CHECK_RESULT(CallbackMemLocation(&alignment_log2, &memidx, &offset)); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1576| 0| break; 1577| 0| } 1578| | 1579| 234| case Opcode::AtomicFence: { ------------------ | Branch (1579:7): [True: 234, False: 379k] ------------------ 1580| 234| uint8_t consistency_model; 1581| 234| CHECK_RESULT(ReadU8(&consistency_model, "consistency model")); ------------------ | | 55| 234| do { \ | | 56| 234| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 234] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 234| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1582| 234| ERROR_UNLESS(consistency_model == 0, ------------------ | | 48| 234|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 234| do { \ | | | | 42| 234| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 234] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 234| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1583| 234| "atomic.fence consistency model must be 0"); 1584| 234| CALLBACK(OnAtomicFenceExpr, consistency_model); ------------------ | | 61| 234| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 234|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 234| do { \ | | | | | | 42| 234| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 234] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 234| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 234| #member " callback failed") ------------------ 1585| 234| CALLBACK(OnOpcodeUint32, consistency_model); ------------------ | | 61| 234| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 234|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 234| do { \ | | | | | | 42| 234| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 234] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 234| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 234| #member " callback failed") ------------------ 1586| 234| break; 1587| 234| } 1588| | 1589| 234| case Opcode::I32AtomicLoad8U: ------------------ | Branch (1589:7): [True: 0, False: 379k] ------------------ 1590| 0| case Opcode::I32AtomicLoad16U: ------------------ | Branch (1590:7): [True: 0, False: 379k] ------------------ 1591| 0| case Opcode::I64AtomicLoad8U: ------------------ | Branch (1591:7): [True: 0, False: 379k] ------------------ 1592| 0| case Opcode::I64AtomicLoad16U: ------------------ | Branch (1592:7): [True: 0, False: 379k] ------------------ 1593| 0| case Opcode::I64AtomicLoad32U: ------------------ | Branch (1593:7): [True: 0, False: 379k] ------------------ 1594| 0| case Opcode::I32AtomicLoad: ------------------ | Branch (1594:7): [True: 0, False: 379k] ------------------ 1595| 0| case Opcode::I64AtomicLoad: { ------------------ | Branch (1595:7): [True: 0, False: 379k] ------------------ 1596| 0| Address alignment_log2; 1597| 0| Index memidx; 1598| 0| Address offset; 1599| 0| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1600| 0| "load alignment", "load memidx", 1601| 0| "load offset")); 1602| 0| CALLBACK(OnAtomicLoadExpr, opcode, memidx, alignment_log2, offset); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1603| 0| CHECK_RESULT(CallbackMemLocation(&alignment_log2, &memidx, &offset)); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1604| 0| break; 1605| 0| } 1606| | 1607| 1| case Opcode::I32AtomicStore8: ------------------ | Branch (1607:7): [True: 1, False: 379k] ------------------ 1608| 1| case Opcode::I32AtomicStore16: ------------------ | Branch (1608:7): [True: 0, False: 379k] ------------------ 1609| 1| case Opcode::I64AtomicStore8: ------------------ | Branch (1609:7): [True: 0, False: 379k] ------------------ 1610| 1| case Opcode::I64AtomicStore16: ------------------ | Branch (1610:7): [True: 0, False: 379k] ------------------ 1611| 1| case Opcode::I64AtomicStore32: ------------------ | Branch (1611:7): [True: 0, False: 379k] ------------------ 1612| 1| case Opcode::I32AtomicStore: ------------------ | Branch (1612:7): [True: 0, False: 379k] ------------------ 1613| 1| case Opcode::I64AtomicStore: { ------------------ | Branch (1613:7): [True: 0, False: 379k] ------------------ 1614| 1| Address alignment_log2; 1615| 1| Index memidx; 1616| 1| Address offset; 1617| 1| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1618| 1| "store alignment", "store memidx", 1619| 1| "store offset")); 1620| 1| CALLBACK(OnAtomicStoreExpr, opcode, memidx, alignment_log2, offset); ------------------ | | 61| 1| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1| do { \ | | | | | | 42| 1| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1| #member " callback failed") ------------------ 1621| 1| CHECK_RESULT(CallbackMemLocation(&alignment_log2, &memidx, &offset)); ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1622| 1| break; 1623| 1| } 1624| | 1625| 1| case Opcode::I32AtomicRmwAdd: ------------------ | Branch (1625:7): [True: 0, False: 379k] ------------------ 1626| 0| case Opcode::I64AtomicRmwAdd: ------------------ | Branch (1626:7): [True: 0, False: 379k] ------------------ 1627| 0| case Opcode::I32AtomicRmw8AddU: ------------------ | Branch (1627:7): [True: 0, False: 379k] ------------------ 1628| 0| case Opcode::I32AtomicRmw16AddU: ------------------ | Branch (1628:7): [True: 0, False: 379k] ------------------ 1629| 0| case Opcode::I64AtomicRmw8AddU: ------------------ | Branch (1629:7): [True: 0, False: 379k] ------------------ 1630| 0| case Opcode::I64AtomicRmw16AddU: ------------------ | Branch (1630:7): [True: 0, False: 379k] ------------------ 1631| 0| case Opcode::I64AtomicRmw32AddU: ------------------ | Branch (1631:7): [True: 0, False: 379k] ------------------ 1632| 0| case Opcode::I32AtomicRmwSub: ------------------ | Branch (1632:7): [True: 0, False: 379k] ------------------ 1633| 0| case Opcode::I64AtomicRmwSub: ------------------ | Branch (1633:7): [True: 0, False: 379k] ------------------ 1634| 0| case Opcode::I32AtomicRmw8SubU: ------------------ | Branch (1634:7): [True: 0, False: 379k] ------------------ 1635| 0| case Opcode::I32AtomicRmw16SubU: ------------------ | Branch (1635:7): [True: 0, False: 379k] ------------------ 1636| 0| case Opcode::I64AtomicRmw8SubU: ------------------ | Branch (1636:7): [True: 0, False: 379k] ------------------ 1637| 0| case Opcode::I64AtomicRmw16SubU: ------------------ | Branch (1637:7): [True: 0, False: 379k] ------------------ 1638| 0| case Opcode::I64AtomicRmw32SubU: ------------------ | Branch (1638:7): [True: 0, False: 379k] ------------------ 1639| 0| case Opcode::I32AtomicRmwAnd: ------------------ | Branch (1639:7): [True: 0, False: 379k] ------------------ 1640| 0| case Opcode::I64AtomicRmwAnd: ------------------ | Branch (1640:7): [True: 0, False: 379k] ------------------ 1641| 0| case Opcode::I32AtomicRmw8AndU: ------------------ | Branch (1641:7): [True: 0, False: 379k] ------------------ 1642| 0| case Opcode::I32AtomicRmw16AndU: ------------------ | Branch (1642:7): [True: 0, False: 379k] ------------------ 1643| 0| case Opcode::I64AtomicRmw8AndU: ------------------ | Branch (1643:7): [True: 0, False: 379k] ------------------ 1644| 0| case Opcode::I64AtomicRmw16AndU: ------------------ | Branch (1644:7): [True: 0, False: 379k] ------------------ 1645| 0| case Opcode::I64AtomicRmw32AndU: ------------------ | Branch (1645:7): [True: 0, False: 379k] ------------------ 1646| 0| case Opcode::I32AtomicRmwOr: ------------------ | Branch (1646:7): [True: 0, False: 379k] ------------------ 1647| 0| case Opcode::I64AtomicRmwOr: ------------------ | Branch (1647:7): [True: 0, False: 379k] ------------------ 1648| 15| case Opcode::I32AtomicRmw8OrU: ------------------ | Branch (1648:7): [True: 15, False: 379k] ------------------ 1649| 15| case Opcode::I32AtomicRmw16OrU: ------------------ | Branch (1649:7): [True: 0, False: 379k] ------------------ 1650| 15| case Opcode::I64AtomicRmw8OrU: ------------------ | Branch (1650:7): [True: 0, False: 379k] ------------------ 1651| 15| case Opcode::I64AtomicRmw16OrU: ------------------ | Branch (1651:7): [True: 0, False: 379k] ------------------ 1652| 15| case Opcode::I64AtomicRmw32OrU: ------------------ | Branch (1652:7): [True: 0, False: 379k] ------------------ 1653| 15| case Opcode::I32AtomicRmwXor: ------------------ | Branch (1653:7): [True: 0, False: 379k] ------------------ 1654| 15| case Opcode::I64AtomicRmwXor: ------------------ | Branch (1654:7): [True: 0, False: 379k] ------------------ 1655| 15| case Opcode::I32AtomicRmw8XorU: ------------------ | Branch (1655:7): [True: 0, False: 379k] ------------------ 1656| 15| case Opcode::I32AtomicRmw16XorU: ------------------ | Branch (1656:7): [True: 0, False: 379k] ------------------ 1657| 15| case Opcode::I64AtomicRmw8XorU: ------------------ | Branch (1657:7): [True: 0, False: 379k] ------------------ 1658| 15| case Opcode::I64AtomicRmw16XorU: ------------------ | Branch (1658:7): [True: 0, False: 379k] ------------------ 1659| 15| case Opcode::I64AtomicRmw32XorU: ------------------ | Branch (1659:7): [True: 0, False: 379k] ------------------ 1660| 15| case Opcode::I32AtomicRmwXchg: ------------------ | Branch (1660:7): [True: 0, False: 379k] ------------------ 1661| 15| case Opcode::I64AtomicRmwXchg: ------------------ | Branch (1661:7): [True: 0, False: 379k] ------------------ 1662| 15| case Opcode::I32AtomicRmw8XchgU: ------------------ | Branch (1662:7): [True: 0, False: 379k] ------------------ 1663| 15| case Opcode::I32AtomicRmw16XchgU: ------------------ | Branch (1663:7): [True: 0, False: 379k] ------------------ 1664| 15| case Opcode::I64AtomicRmw8XchgU: ------------------ | Branch (1664:7): [True: 0, False: 379k] ------------------ 1665| 15| case Opcode::I64AtomicRmw16XchgU: ------------------ | Branch (1665:7): [True: 0, False: 379k] ------------------ 1666| 15| case Opcode::I64AtomicRmw32XchgU: { ------------------ | Branch (1666:7): [True: 0, False: 379k] ------------------ 1667| 15| Address alignment_log2; 1668| 15| Index memidx; 1669| 15| Address offset; 1670| 15| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 15| do { \ | | 56| 15| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 15] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 15| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1671| 15| "memory alignment", "memory memidx", 1672| 15| "memory offset")); 1673| 15| CALLBACK(OnAtomicRmwExpr, opcode, memidx, alignment_log2, offset); ------------------ | | 61| 15| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 15|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 15| do { \ | | | | | | 42| 15| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 15] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 15| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 15| #member " callback failed") ------------------ 1674| 15| CHECK_RESULT(CallbackMemLocation(&alignment_log2, &memidx, &offset)); ------------------ | | 55| 15| do { \ | | 56| 15| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 15] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 15| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1675| 15| break; 1676| 15| } 1677| | 1678| 15| case Opcode::I32AtomicRmwCmpxchg: ------------------ | Branch (1678:7): [True: 0, False: 379k] ------------------ 1679| 0| case Opcode::I64AtomicRmwCmpxchg: ------------------ | Branch (1679:7): [True: 0, False: 379k] ------------------ 1680| 0| case Opcode::I32AtomicRmw8CmpxchgU: ------------------ | Branch (1680:7): [True: 0, False: 379k] ------------------ 1681| 0| case Opcode::I32AtomicRmw16CmpxchgU: ------------------ | Branch (1681:7): [True: 0, False: 379k] ------------------ 1682| 0| case Opcode::I64AtomicRmw8CmpxchgU: ------------------ | Branch (1682:7): [True: 0, False: 379k] ------------------ 1683| 0| case Opcode::I64AtomicRmw16CmpxchgU: ------------------ | Branch (1683:7): [True: 0, False: 379k] ------------------ 1684| 0| case Opcode::I64AtomicRmw32CmpxchgU: { ------------------ | Branch (1684:7): [True: 0, False: 379k] ------------------ 1685| 0| Address alignment_log2; 1686| 0| Index memidx; 1687| 0| Address offset; 1688| 0| CHECK_RESULT(ReadMemLocation(&alignment_log2, &memidx, &offset, ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1689| 0| "memory alignment", "memory memidx", 1690| 0| "memory offset")); 1691| 0| CALLBACK(OnAtomicRmwCmpxchgExpr, opcode, memidx, alignment_log2, ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1692| 0| offset); 1693| 0| CHECK_RESULT(CallbackMemLocation(&alignment_log2, &memidx, &offset)); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1694| 0| break; 1695| 0| } 1696| | 1697| 0| case Opcode::TableInit: { ------------------ | Branch (1697:7): [True: 0, False: 379k] ------------------ 1698| 0| Index segment; 1699| 0| CHECK_RESULT(ReadIndex(&segment, "elem segment index")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1700| 0| Index table_index; 1701| 0| CHECK_RESULT(ReadIndex(&table_index, "reserved table index")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1702| 0| CALLBACK(OnTableInitExpr, segment, table_index); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1703| 0| CALLBACK(OnOpcodeUint32Uint32, segment, table_index); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1704| 0| break; 1705| 0| } 1706| | 1707| 0| case Opcode::MemoryInit: { ------------------ | Branch (1707:7): [True: 0, False: 379k] ------------------ 1708| 0| Index segment; 1709| 0| ERROR_IF(data_count_ == kInvalidIndex, ------------------ | | 41| 0| do { \ | | 42| 0| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 0, False: 0] | | ------------------ | | 43| 0| PrintError(__VA_ARGS__); \ | | 44| 0| return Result::Error; \ | | 45| 0| } \ | | 46| 0| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 1710| 0| "memory.init requires data count section"); 1711| 0| CHECK_RESULT(ReadIndex(&segment, "elem segment index")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1712| 0| Index memidx = 0; 1713| 0| if (!options_.features.multi_memory_enabled()) { ------------------ | Branch (1713:13): [True: 0, False: 0] ------------------ 1714| 0| uint8_t reserved; 1715| 0| CHECK_RESULT(ReadU8(&reserved, "reserved memory index")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1716| 0| ERROR_UNLESS(reserved == 0, "reserved value must be 0"); ------------------ | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 0| do { \ | | | | 42| 0| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 0| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1717| 0| } else { 1718| 0| CHECK_RESULT(ReadMemidx(&memidx, "memory.init memidx")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1719| 0| } 1720| 0| CALLBACK(OnMemoryInitExpr, segment, memidx); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1721| 0| CALLBACK(OnOpcodeUint32Uint32, segment, memidx); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1722| 0| break; 1723| 0| } 1724| | 1725| 1| case Opcode::DataDrop: ------------------ | Branch (1725:7): [True: 1, False: 379k] ------------------ 1726| 1| ERROR_IF(data_count_ == kInvalidIndex, ------------------ | | 41| 1| do { \ | | 42| 1| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 0, False: 1] | | ------------------ | | 43| 0| PrintError(__VA_ARGS__); \ | | 44| 0| return Result::Error; \ | | 45| 0| } \ | | 46| 1| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 1727| 1| "data.drop requires data count section"); 1728| 1| [[fallthrough]]; 1729| 1| case Opcode::ElemDrop: { ------------------ | Branch (1729:7): [True: 0, False: 379k] ------------------ 1730| 1| Index segment; 1731| 1| CHECK_RESULT(ReadIndex(&segment, "segment index")); ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1732| 1| if (opcode == Opcode::DataDrop) { ------------------ | Branch (1732:13): [True: 1, False: 0] ------------------ 1733| 1| CALLBACK(OnDataDropExpr, segment); ------------------ | | 61| 1| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1| do { \ | | | | | | 42| 1| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1| #member " callback failed") ------------------ 1734| 1| } else { 1735| 0| CALLBACK(OnElemDropExpr, segment); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1736| 0| } 1737| 1| CALLBACK(OnOpcodeUint32, segment); ------------------ | | 61| 1| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1| do { \ | | | | | | 42| 1| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1| #member " callback failed") ------------------ 1738| 1| break; 1739| 1| } 1740| | 1741| 297| case Opcode::MemoryFill: { ------------------ | Branch (1741:7): [True: 297, False: 379k] ------------------ 1742| 297| Index memidx = 0; 1743| 297| if (!options_.features.multi_memory_enabled()) { ------------------ | Branch (1743:13): [True: 108, False: 189] ------------------ 1744| 108| uint8_t reserved; 1745| 108| CHECK_RESULT(ReadU8(&reserved, "memory.fill reserved")); ------------------ | | 55| 108| do { \ | | 56| 108| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 108] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 108| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1746| 108| ERROR_UNLESS(reserved == 0, "memory.fill reserved value must be 0"); ------------------ | | 48| 108|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 108| do { \ | | | | 42| 108| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 108] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 108| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1747| 189| } else { 1748| 189| CHECK_RESULT(ReadMemidx(&memidx, "memory.fill memidx")); ------------------ | | 55| 189| do { \ | | 56| 189| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 189] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 189| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1749| 189| } 1750| 297| CALLBACK(OnMemoryFillExpr, memidx); ------------------ | | 61| 297| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 297|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 297| do { \ | | | | | | 42| 297| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 1, False: 296] | | | | | | ------------------ | | | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | | | 44| 1| return Result::Error; \ | | | | | | 45| 1| } \ | | | | | | 46| 297| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 297| #member " callback failed") ------------------ 1751| 296| CALLBACK(OnOpcodeUint32, memidx); ------------------ | | 61| 296| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 296|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 296| do { \ | | | | | | 42| 296| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 296] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 296| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 296| #member " callback failed") ------------------ 1752| 296| break; 1753| 296| } 1754| | 1755| 296| case Opcode::MemoryCopy: { ------------------ | Branch (1755:7): [True: 0, False: 379k] ------------------ 1756| 0| Index destmemidx = 0; 1757| 0| Index srcmemidx = 0; 1758| 0| if (!options_.features.multi_memory_enabled()) { ------------------ | Branch (1758:13): [True: 0, False: 0] ------------------ 1759| 0| uint8_t reserved; 1760| 0| CHECK_RESULT(ReadU8(&reserved, "reserved memory index")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1761| 0| ERROR_UNLESS(reserved == 0, "reserved value must be 0"); ------------------ | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 0| do { \ | | | | 42| 0| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 0| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1762| 0| CHECK_RESULT(ReadU8(&reserved, "reserved memory index")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1763| 0| ERROR_UNLESS(reserved == 0, "reserved value must be 0"); ------------------ | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 0| do { \ | | | | 42| 0| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 0| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1764| 0| } else { 1765| 0| CHECK_RESULT(ReadMemidx(&destmemidx, "memory.copy destmemindex")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1766| 0| CHECK_RESULT(ReadMemidx(&srcmemidx, "memory.copy srcmemidx")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1767| 0| } 1768| 0| CALLBACK(OnMemoryCopyExpr, destmemidx, srcmemidx); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1769| 0| CALLBACK(OnOpcodeUint32Uint32, destmemidx, srcmemidx); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1770| 0| break; 1771| 0| } 1772| | 1773| 53| case Opcode::TableCopy: { ------------------ | Branch (1773:7): [True: 53, False: 379k] ------------------ 1774| 53| Index table_dst; 1775| 53| Index table_src; 1776| 53| CHECK_RESULT(ReadIndex(&table_dst, "reserved table index")); ------------------ | | 55| 53| do { \ | | 56| 53| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 53] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 53| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1777| 53| CHECK_RESULT(ReadIndex(&table_src, "table src")); ------------------ | | 55| 53| do { \ | | 56| 53| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 53] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 53| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1778| 53| CALLBACK(OnTableCopyExpr, table_dst, table_src); ------------------ | | 61| 53| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 53|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 53| do { \ | | | | | | 42| 53| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 1, False: 52] | | | | | | ------------------ | | | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | | | 44| 1| return Result::Error; \ | | | | | | 45| 1| } \ | | | | | | 46| 53| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 53| #member " callback failed") ------------------ 1779| 52| CALLBACK(OnOpcodeUint32Uint32, table_dst, table_src); ------------------ | | 61| 52| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 52|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 52| do { \ | | | | | | 42| 52| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 52] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 52| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 52| #member " callback failed") ------------------ 1780| 52| break; 1781| 52| } 1782| | 1783| 52| case Opcode::TableGet: { ------------------ | Branch (1783:7): [True: 50, False: 379k] ------------------ 1784| 50| Index table; 1785| 50| CHECK_RESULT(ReadIndex(&table, "table index")); ------------------ | | 55| 50| do { \ | | 56| 50| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 50] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 50| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1786| 50| CALLBACK(OnTableGetExpr, table); ------------------ | | 61| 50| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 50|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 50| do { \ | | | | | | 42| 50| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 1, False: 49] | | | | | | ------------------ | | | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | | | 44| 1| return Result::Error; \ | | | | | | 45| 1| } \ | | | | | | 46| 50| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 50| #member " callback failed") ------------------ 1787| 49| CALLBACK(OnOpcodeUint32, table); ------------------ | | 61| 49| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 49|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 49| do { \ | | | | | | 42| 49| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 49] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 49| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 49| #member " callback failed") ------------------ 1788| 49| break; 1789| 49| } 1790| | 1791| 94| case Opcode::TableSet: { ------------------ | Branch (1791:7): [True: 94, False: 379k] ------------------ 1792| 94| Index table; 1793| 94| CHECK_RESULT(ReadIndex(&table, "table index")); ------------------ | | 55| 94| do { \ | | 56| 94| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 94] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 94| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1794| 94| CALLBACK(OnTableSetExpr, table); ------------------ | | 61| 94| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 94|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 94| do { \ | | | | | | 42| 94| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 3, False: 91] | | | | | | ------------------ | | | | | | 43| 3| PrintError(__VA_ARGS__); \ | | | | | | 44| 3| return Result::Error; \ | | | | | | 45| 3| } \ | | | | | | 46| 94| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 94| #member " callback failed") ------------------ 1795| 91| CALLBACK(OnOpcodeUint32, table); ------------------ | | 61| 91| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 91|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 91| do { \ | | | | | | 42| 91| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 91] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 91| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 91| #member " callback failed") ------------------ 1796| 91| break; 1797| 91| } 1798| | 1799| 91| case Opcode::TableGrow: { ------------------ | Branch (1799:7): [True: 0, False: 379k] ------------------ 1800| 0| Index table; 1801| 0| CHECK_RESULT(ReadIndex(&table, "table index")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1802| 0| CALLBACK(OnTableGrowExpr, table); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1803| 0| CALLBACK(OnOpcodeUint32, table); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1804| 0| break; 1805| 0| } 1806| | 1807| 0| case Opcode::TableSize: { ------------------ | Branch (1807:7): [True: 0, False: 379k] ------------------ 1808| 0| Index table; 1809| 0| CHECK_RESULT(ReadIndex(&table, "table index")); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1810| 0| CALLBACK(OnTableSizeExpr, table); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1811| 0| CALLBACK(OnOpcodeUint32, table); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 1812| 0| break; 1813| 0| } 1814| | 1815| 65| case Opcode::TableFill: { ------------------ | Branch (1815:7): [True: 65, False: 379k] ------------------ 1816| 65| Index table; 1817| 65| CHECK_RESULT(ReadIndex(&table, "table index")); ------------------ | | 55| 65| do { \ | | 56| 65| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 65] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 65| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1818| 65| CALLBACK(OnTableFillExpr, table); ------------------ | | 61| 65| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 65|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 65| do { \ | | | | | | 42| 65| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 65] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 65| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 65| #member " callback failed") ------------------ 1819| 65| CALLBACK(OnOpcodeUint32, table); ------------------ | | 61| 65| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 65|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 65| do { \ | | | | | | 42| 65| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 65] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 65| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 65| #member " callback failed") ------------------ 1820| 65| break; 1821| 65| } 1822| | 1823| 65| case Opcode::RefFunc: { ------------------ | Branch (1823:7): [True: 13, False: 379k] ------------------ 1824| 13| Index func; 1825| 13| CHECK_RESULT(ReadIndex(&func, "func index")); ------------------ | | 55| 13| do { \ | | 56| 13| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 13] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 13| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1826| 13| CALLBACK(OnRefFuncExpr, func); ------------------ | | 61| 13| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 13|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 13| do { \ | | | | | | 42| 13| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 1, False: 12] | | | | | | ------------------ | | | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | | | 44| 1| return Result::Error; \ | | | | | | 45| 1| } \ | | | | | | 46| 13| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 13| #member " callback failed") ------------------ 1827| 12| CALLBACK(OnOpcodeUint32, func); ------------------ | | 61| 12| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 12|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 12| do { \ | | | | | | 42| 12| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 12] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 12| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 12| #member " callback failed") ------------------ 1828| 12| break; 1829| 12| } 1830| | 1831| 31| case Opcode::RefNull: { ------------------ | Branch (1831:7): [True: 31, False: 379k] ------------------ 1832| 31| Type type; 1833| 31| CHECK_RESULT(ReadRefType(&type, "ref.null type")); ------------------ | | 55| 31| do { \ | | 56| 31| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 4, False: 27] | | ------------------ | | 57| 4| return ::wabt::Result::Error; \ | | 58| 4| } \ | | 59| 31| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1834| 27| CALLBACK(OnRefNullExpr, type); ------------------ | | 61| 27| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 27|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 27| do { \ | | | | | | 42| 27| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 27] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 27| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 27| #member " callback failed") ------------------ 1835| 27| CALLBACK(OnOpcodeType, type); ------------------ | | 61| 27| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 27|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 27| do { \ | | | | | | 42| 27| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 27] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 27| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 27| #member " callback failed") ------------------ 1836| 27| break; 1837| 27| } 1838| | 1839| 34| case Opcode::RefIsNull: ------------------ | Branch (1839:7): [True: 34, False: 379k] ------------------ 1840| 34| CALLBACK(OnRefIsNullExpr); ------------------ | | 61| 34| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 34|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 34| do { \ | | | | | | 42| 34| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 34] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 34| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 34| #member " callback failed") ------------------ 1841| 34| CALLBACK(OnOpcodeBare); ------------------ | | 61| 34| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 34|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 34| do { \ | | | | | | 42| 34| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 34] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 34| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 34| #member " callback failed") ------------------ 1842| 34| break; 1843| | 1844| 107| case Opcode::CallRef: ------------------ | Branch (1844:7): [True: 107, False: 379k] ------------------ 1845| 107| CALLBACK(OnCallRefExpr); ------------------ | | 61| 107| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 107|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 107| do { \ | | | | | | 42| 107| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 107] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 107| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 107| #member " callback failed") ------------------ 1846| 107| CALLBACK(OnOpcodeBare); ------------------ | | 61| 107| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 107|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 107| do { \ | | | | | | 42| 107| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 107] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 107| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 107| #member " callback failed") ------------------ 1847| 107| break; 1848| | 1849| 107| default: ------------------ | Branch (1849:7): [True: 81, False: 379k] ------------------ 1850| 81| return ReportUnexpectedOpcode(opcode); 1851| 379k| } 1852| 379k| } 1853| | 1854| 42| PrintError("%s must end with END opcode", context); 1855| 42| return Result::Error; 1856| 2.45k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader10ReadOpcodeEPNS_6OpcodeEPKc: 260| 379k|Result BinaryReader::ReadOpcode(Opcode* out_value, const char* desc) { 261| 379k| uint8_t value = 0; 262| 379k| CHECK_RESULT(ReadU8(&value, desc)); ------------------ | | 55| 379k| do { \ | | 56| 379k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 379k] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 379k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 263| | 264| 379k| if (Opcode::IsPrefixByte(value)) { ------------------ | Branch (264:7): [True: 48.5k, False: 331k] ------------------ 265| 48.5k| uint32_t code; 266| 48.5k| CHECK_RESULT(ReadU32Leb128(&code, desc)); ------------------ | | 55| 48.5k| do { \ | | 56| 48.5k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5, False: 48.5k] | | ------------------ | | 57| 5| return ::wabt::Result::Error; \ | | 58| 5| } \ | | 59| 48.5k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 267| 48.5k| *out_value = Opcode::FromCode(value, code); 268| 331k| } else { 269| 331k| *out_value = Opcode::FromCode(value); 270| 331k| } 271| 379k| return Result::Ok; 272| 379k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader22ReportUnexpectedOpcodeENS_6OpcodeEPKc: 240| 100|Result BinaryReader::ReportUnexpectedOpcode(Opcode opcode, const char* where) { 241| 100| std::string message = "unexpected opcode"; 242| 100| if (where) { ------------------ | Branch (242:7): [True: 0, False: 100] ------------------ 243| 0| message += ' '; 244| 0| message += where; 245| 0| } 246| | 247| 100| message += ":"; 248| | 249| 100| std::vector bytes = opcode.GetBytes(); 250| 100| assert(bytes.size() > 0); 251| | 252| 137| for (uint8_t byte : bytes) { ------------------ | Branch (252:21): [True: 137, False: 100] ------------------ 253| 137| message += StringPrintf(" 0x%x", byte); 254| 137| } 255| | 256| 100| PrintError("%s", message.c_str()); 257| 100| return Result::Error; 258| 100|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader11IsBlockTypeENS_4TypeE: 551| 3.01k|bool BinaryReader::IsBlockType(Type type) { 552| 3.01k| if (IsConcreteType(type) || type == Type::Void) { ------------------ | Branch (552:7): [True: 428, False: 2.58k] | Branch (552:31): [True: 526, False: 2.05k] ------------------ 553| 954| return true; 554| 954| } 555| | 556| 2.05k| if (!(options_.features.multi_value_enabled() && type.IsIndex())) { ------------------ | Branch (556:9): [True: 2.05k, False: 0] | Branch (556:52): [True: 2.05k, False: 6] ------------------ 557| 6| return false; 558| 6| } 559| | 560| 2.05k| return true; 561| 2.05k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader13ReadS64Leb128EPmPKc: 341| 574|Result BinaryReader::ReadS64Leb128(uint64_t* out_value, const char* desc) { 342| 574| const uint8_t* p = state_.data + state_.offset; 343| 574| const uint8_t* end = state_.data + read_end_; 344| 574| size_t bytes_read = wabt::ReadS64Leb128(p, end, out_value); 345| 574| ERROR_UNLESS(bytes_read > 0, "unable to read i64 leb128: %s", desc); ------------------ | | 48| 574|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 574| do { \ | | | | 42| 574| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 574] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 574| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 346| 574| state_.offset += bytes_read; 347| 574| return Result::Ok; 348| 574|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader7ReadF32EPjPKc: 302| 2.11k|Result BinaryReader::ReadF32(uint32_t* out_value, const char* desc) { 303| 2.11k| return ReadT(out_value, "float", desc); 304| 2.11k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader7ReadF64EPmPKc: 306| 136|Result BinaryReader::ReadF64(uint64_t* out_value, const char* desc) { 307| 136| return ReadT(out_value, "double", desc); 308| 136|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader5ReadTImEENS_6ResultEPT_PKcS7_: 277| 136| const char* desc) { 278| 136| if (state_.offset + sizeof(T) > read_end_) { ------------------ | Branch (278:7): [True: 0, False: 136] ------------------ 279| 0| PrintError("unable to read %s: %s", type_name, desc); 280| 0| return Result::Error; 281| 0| } 282| |#if WABT_BIG_ENDIAN 283| | uint8_t tmp[sizeof(T)]; 284| | memcpy(tmp, state_.data + state_.offset, sizeof(tmp)); 285| | SwapBytesSized(tmp, sizeof(tmp)); 286| | memcpy(out_value, tmp, sizeof(T)); 287| |#else 288| 136| memcpy(out_value, state_.data + state_.offset, sizeof(T)); 289| 136|#endif 290| 136| state_.offset += sizeof(T); 291| 136| return Result::Ok; 292| 136|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader8ReadV128EP4v128PKc: 310| 26|Result BinaryReader::ReadV128(v128* out_value, const char* desc) { 311| 26| return ReadT(out_value, "v128", desc); 312| 26|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader5ReadTI4v128EENS_6ResultEPT_PKcS8_: 277| 26| const char* desc) { 278| 26| if (state_.offset + sizeof(T) > read_end_) { ------------------ | Branch (278:7): [True: 0, False: 26] ------------------ 279| 0| PrintError("unable to read %s: %s", type_name, desc); 280| 0| return Result::Error; 281| 0| } 282| |#if WABT_BIG_ENDIAN 283| | uint8_t tmp[sizeof(T)]; 284| | memcpy(tmp, state_.data + state_.offset, sizeof(tmp)); 285| | SwapBytesSized(tmp, sizeof(tmp)); 286| | memcpy(out_value, tmp, sizeof(T)); 287| |#else 288| 26| memcpy(out_value, state_.data + state_.offset, sizeof(T)); 289| 26|#endif 290| 26| state_.offset += sizeof(T); 291| 26| return Result::Ok; 292| 26|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader15ReadMemLocationEPmPjS2_PKcS5_S5_Ph: 455| 5.76k| uint8_t* lane_val) { 456| 5.76k| CHECK_RESULT(ReadAlignment(alignment_log2, desc_align)); ------------------ | | 55| 5.76k| do { \ | | 56| 5.76k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 13, False: 5.74k] | | ------------------ | | 57| 13| return ::wabt::Result::Error; \ | | 58| 13| } \ | | 59| 5.76k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 457| 5.74k| *memidx = 0; 458| 5.74k| if (*alignment_log2 >> 6) { ------------------ | Branch (458:7): [True: 7, False: 5.74k] ------------------ 459| 7| ERROR_IF(!options_.features.multi_memory_enabled(), ------------------ | | 41| 7| do { \ | | 42| 7| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 0, False: 7] | | ------------------ | | 43| 0| PrintError(__VA_ARGS__); \ | | 44| 0| return Result::Error; \ | | 45| 0| } \ | | 46| 7| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 460| 7| "multi_memory not allowed"); 461| 7| *alignment_log2 = *alignment_log2 & ((1 << 6) - 1); 462| 7| CHECK_RESULT(ReadMemidx(memidx, desc_memidx)); ------------------ | | 55| 7| do { \ | | 56| 7| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 6] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 7| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 463| 7| } 464| 5.74k| CHECK_RESULT(ReadAddress(offset, 0, desc_offset)); ------------------ | | 55| 5.74k| do { \ | | 56| 5.74k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 5.74k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 5.74k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 465| | 466| 5.74k| if (lane_val) { ------------------ | Branch (466:7): [True: 371, False: 5.37k] ------------------ 467| 371| CHECK_RESULT(ReadU8(lane_val, "Lane idx")); ------------------ | | 55| 371| do { \ | | 56| 371| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 370] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 371| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 468| 371| } 469| | 470| 5.74k| return Result::Ok; 471| 5.74k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader11ReadAddressEPmjPKc: 656| 5.74k| const char* desc) { 657| 5.74k| if (options_.features.memory64_enabled()) { ------------------ | Branch (657:7): [True: 3.28k, False: 2.46k] ------------------ 658| 3.28k| return ReadU64Leb128(out_value, desc); 659| 3.28k| } else { 660| 2.46k| uint32_t val; 661| 2.46k| Result res = ReadU32Leb128(&val, desc); 662| 2.46k| *out_value = val; 663| 2.46k| return res; 664| 2.46k| } 665| 5.74k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader19CallbackMemLocationEPKmPKjS3_PKh: 476| 5.70k| const uint8_t* lane_val) { 477| 5.70k| if (lane_val) { ------------------ | Branch (477:7): [True: 361, False: 5.34k] ------------------ 478| 361| if (*memidx) { ------------------ | Branch (478:9): [True: 0, False: 361] ------------------ 479| 0| CALLBACK(OnOpcodeUint32Uint32Uint32Uint32, *alignment_log2, *memidx, ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 480| 0| *offset, *lane_val); 481| 361| } else { 482| 361| CALLBACK(OnOpcodeUint32Uint32Uint32, *alignment_log2, *offset, *lane_val); ------------------ | | 61| 361| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 361|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 361| do { \ | | | | | | 42| 361| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 361] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 361| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 361| #member " callback failed") ------------------ 483| 361| } 484| 5.34k| } else { 485| 5.34k| if (*memidx) { ------------------ | Branch (485:9): [True: 0, False: 5.34k] ------------------ 486| 0| CALLBACK(OnOpcodeUint32Uint32Uint32, *alignment_log2, *memidx, *offset); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 487| 5.34k| } else { 488| 5.34k| CALLBACK(OnOpcodeUint32Uint32, *alignment_log2, *offset); ------------------ | | 61| 5.34k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 5.34k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 5.34k| do { \ | | | | | | 42| 5.34k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 5.34k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 5.34k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 5.34k| #member " callback failed") ------------------ 489| 5.34k| } 490| 5.34k| } 491| | 492| 5.70k| return Result::Ok; 493| 5.70k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader10ReadMemidxEPjPKc: 444| 276|Result BinaryReader::ReadMemidx(Index* memidx, const char* desc) { 445| 276| CHECK_RESULT(ReadIndex(memidx, desc)); ------------------ | | 55| 276| do { \ | | 56| 276| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 275] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 276| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 446| 275| return Result::Ok; 447| 276|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ReadExportSectionEm: 2668| 355|Result BinaryReader::ReadExportSection(Offset section_size) { 2669| 355| CALLBACK(BeginExportSection, section_size); ------------------ | | 61| 355| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 355|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 355| do { \ | | | | | | 42| 355| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 355] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 355| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 355| #member " callback failed") ------------------ 2670| 355| Index num_exports; 2671| 355| CHECK_RESULT(ReadCount(&num_exports, "export count")); ------------------ | | 55| 355| do { \ | | 56| 355| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5, False: 350] | | ------------------ | | 57| 5| return ::wabt::Result::Error; \ | | 58| 5| } \ | | 59| 355| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2672| 350| CALLBACK(OnExportCount, num_exports); ------------------ | | 61| 350| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 350|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 350| do { \ | | | | | | 42| 350| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 350] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 350| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 350| #member " callback failed") ------------------ 2673| 2.35k| for (Index i = 0; i < num_exports; ++i) { ------------------ | Branch (2673:21): [True: 2.23k, False: 127] ------------------ 2674| 2.23k| std::string_view name; 2675| 2.23k| CHECK_RESULT(ReadStr(&name, "export item name")); ------------------ | | 55| 2.23k| do { \ | | 56| 2.23k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 128, False: 2.10k] | | ------------------ | | 57| 128| return ::wabt::Result::Error; \ | | 58| 128| } \ | | 59| 2.23k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2676| | 2677| 2.10k| ExternalKind kind; 2678| 2.10k| CHECK_RESULT(ReadExternalKind(&kind, "export kind")); ------------------ | | 55| 2.10k| do { \ | | 56| 2.10k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 63, False: 2.04k] | | ------------------ | | 57| 63| return ::wabt::Result::Error; \ | | 58| 63| } \ | | 59| 2.10k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2679| | 2680| 2.04k| Index item_index; 2681| 2.04k| CHECK_RESULT(ReadIndex(&item_index, "export item index")); ------------------ | | 55| 2.04k| do { \ | | 56| 2.04k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 2.03k] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 2.04k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2682| 2.03k| if (kind == ExternalKind::Tag) { ------------------ | Branch (2682:9): [True: 1, False: 2.03k] ------------------ 2683| 1| ERROR_UNLESS(options_.features.exceptions_enabled(), ------------------ | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 1| do { \ | | | | 42| 1| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 1] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 1| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2684| 1| "invalid export tag kind: exceptions not allowed"); 2685| 1| } 2686| | 2687| 2.03k| CALLBACK(OnExport, i, static_cast(kind), item_index, name); ------------------ | | 61| 2.03k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2.03k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.03k| do { \ | | | | | | 42| 2.03k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 30, False: 2.00k] | | | | | | ------------------ | | | | | | 43| 30| PrintError(__VA_ARGS__); \ | | | | | | 44| 30| return Result::Error; \ | | | | | | 45| 30| } \ | | | | | | 46| 2.03k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2.03k| #member " callback failed") ------------------ 2688| 2.03k| } 2689| 127| CALLBACK0(EndExportSection); ------------------ | | 58| 127| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 127|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 127| do { \ | | | | | | 42| 127| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 127] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 127| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2690| 127| return Result::Ok; 2691| 127|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader16ReadExternalKindEPNS_12ExternalKindEPKc: 372| 2.10k| const char* desc) { 373| 2.10k| uint8_t value = 0; 374| 2.10k| CHECK_RESULT(ReadU8(&value, desc)); ------------------ | | 55| 2.10k| do { \ | | 56| 2.10k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2.10k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2.10k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 375| 2.10k| ERROR_UNLESS(value < kExternalKindCount, "invalid export external kind: %d", ------------------ | | 48| 2.10k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 2.10k| do { \ | | | | 42| 2.10k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 63, False: 2.04k] | | | | ------------------ | | | | 43| 63| PrintError(__VA_ARGS__); \ | | | | 44| 63| return Result::Error; \ | | | | 45| 63| } \ | | | | 46| 2.10k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 376| 2.04k| value); 377| 2.04k| *out_value = static_cast(value); 378| 2.04k| return Result::Ok; 379| 2.10k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader16ReadStartSectionEm: 2693| 18|Result BinaryReader::ReadStartSection(Offset section_size) { 2694| 18| CALLBACK(BeginStartSection, section_size); ------------------ | | 61| 18| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 18|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 18| do { \ | | | | | | 42| 18| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 18] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 18| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 18| #member " callback failed") ------------------ 2695| 18| Index func_index; 2696| 18| CHECK_RESULT(ReadIndex(&func_index, "start function index")); ------------------ | | 55| 18| do { \ | | 56| 18| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 9, False: 9] | | ------------------ | | 57| 9| return ::wabt::Result::Error; \ | | 58| 9| } \ | | 59| 18| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2697| 9| CALLBACK(OnStartFunction, func_index); ------------------ | | 61| 9| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 9|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 9| do { \ | | | | | | 42| 9| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 9, False: 0] | | | | | | ------------------ | | | | | | 43| 9| PrintError(__VA_ARGS__); \ | | | | | | 44| 9| return Result::Error; \ | | | | | | 45| 9| } \ | | | | | | 46| 9| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 9| #member " callback failed") ------------------ 2698| 0| CALLBACK0(EndStartSection); ------------------ | | 58| 0| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2699| 0| return Result::Ok; 2700| 0|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader15ReadElemSectionEm: 2702| 43|Result BinaryReader::ReadElemSection(Offset section_size) { 2703| 43| CALLBACK(BeginElemSection, section_size); ------------------ | | 61| 43| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 43|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 43| do { \ | | | | | | 42| 43| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 43] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 43| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 43| #member " callback failed") ------------------ 2704| 43| Index num_elem_segments; 2705| 43| CHECK_RESULT(ReadCount(&num_elem_segments, "elem segment count")); ------------------ | | 55| 43| do { \ | | 56| 43| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 10, False: 33] | | ------------------ | | 57| 10| return ::wabt::Result::Error; \ | | 58| 10| } \ | | 59| 43| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2706| 33| CALLBACK(OnElemSegmentCount, num_elem_segments); ------------------ | | 61| 33| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 33|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 33| do { \ | | | | | | 42| 33| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 33] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 33| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 33| #member " callback failed") ------------------ 2707| 44| for (Index i = 0; i < num_elem_segments; ++i) { ------------------ | Branch (2707:21): [True: 27, False: 17] ------------------ 2708| 27| uint32_t flags; 2709| 27| CHECK_RESULT(ReadU32Leb128(&flags, "elem segment flags")); ------------------ | | 55| 27| do { \ | | 56| 27| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 27] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 27| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2710| 27| ERROR_IF(flags > SegFlagMax, "invalid elem segment flags: %#x", flags); ------------------ | | 41| 27| do { \ | | 42| 27| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 5, False: 22] | | ------------------ | | 43| 5| PrintError(__VA_ARGS__); \ | | 44| 5| return Result::Error; \ | | 45| 5| } \ | | 46| 27| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 2711| 22| Index table_index(0); 2712| 22| if ((flags & (SegPassive | SegExplicitIndex)) == SegExplicitIndex) { ------------------ | Branch (2712:9): [True: 1, False: 21] ------------------ 2713| 1| CHECK_RESULT(ReadIndex(&table_index, "elem segment table index")); ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2714| 1| } 2715| 22| Type elem_type = Type::FuncRef; 2716| | 2717| 22| CALLBACK(BeginElemSegment, i, table_index, flags); ------------------ | | 61| 22| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 22|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 22| do { \ | | | | | | 42| 22| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 5, False: 17] | | | | | | ------------------ | | | | | | 43| 5| PrintError(__VA_ARGS__); \ | | | | | | 44| 5| return Result::Error; \ | | | | | | 45| 5| } \ | | | | | | 46| 22| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 22| #member " callback failed") ------------------ 2718| | 2719| 17| if (!(flags & SegPassive)) { ------------------ | Branch (2719:9): [True: 15, False: 2] ------------------ 2720| 15| CALLBACK(BeginElemSegmentInitExpr, i); ------------------ | | 61| 15| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 15|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 15| do { \ | | | | | | 42| 15| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 15] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 15| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 15| #member " callback failed") ------------------ 2721| 15| CHECK_RESULT(ReadInitExpr(i)); ------------------ | | 55| 15| do { \ | | 56| 15| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 15] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 15| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2722| 15| CALLBACK(EndElemSegmentInitExpr, i); ------------------ | | 61| 15| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 15|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 15| do { \ | | | | | | 42| 15| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 15] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 15| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 15| #member " callback failed") ------------------ 2723| 15| } 2724| | 2725| | // For backwards compat we support not declaring the element kind. 2726| 17| if (flags & (SegPassive | SegExplicitIndex)) { ------------------ | Branch (2726:9): [True: 2, False: 15] ------------------ 2727| 2| if (flags & SegUseElemExprs) { ------------------ | Branch (2727:11): [True: 1, False: 1] ------------------ 2728| 1| CHECK_RESULT(ReadRefType(&elem_type, "table elem type")); ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2729| 1| } else { 2730| 1| ExternalKind kind; 2731| 1| CHECK_RESULT(ReadExternalKind(&kind, "export kind")); ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2732| 1| ERROR_UNLESS(kind == ExternalKind::Func, ------------------ | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 1| do { \ | | | | 42| 1| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 1] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 1| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2733| 1| "segment elem type must be func (%s)", 2734| 1| elem_type.GetName().c_str()); 2735| 1| elem_type = Type::FuncRef; 2736| 1| } 2737| 2| } 2738| | 2739| 17| CALLBACK(OnElemSegmentElemType, i, elem_type); ------------------ | | 61| 17| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 17|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 17| do { \ | | | | | | 42| 17| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 17] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 17| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 17| #member " callback failed") ------------------ 2740| | 2741| 17| Index num_elem_exprs; 2742| 17| CHECK_RESULT(ReadCount(&num_elem_exprs, "elem count")); ------------------ | | 55| 17| do { \ | | 56| 17| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 16] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 17| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2743| | 2744| 16| CALLBACK(OnElemSegmentElemExprCount, i, num_elem_exprs); ------------------ | | 61| 16| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 16|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 16| do { \ | | | | | | 42| 16| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 16] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 16| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 16| #member " callback failed") ------------------ 2745| 93| for (Index j = 0; j < num_elem_exprs; ++j) { ------------------ | Branch (2745:23): [True: 82, False: 11] ------------------ 2746| 82| CALLBACK(BeginElemExpr, i, j); ------------------ | | 61| 82| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 82|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 82| do { \ | | | | | | 42| 82| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 82] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 82| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 82| #member " callback failed") ------------------ 2747| 82| if (flags & SegUseElemExprs) { ------------------ | Branch (2747:11): [True: 0, False: 82] ------------------ 2748| 0| CHECK_RESULT(ReadInitExpr(j)); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2749| 82| } else { 2750| 82| Index func_index; 2751| 82| CHECK_RESULT(ReadIndex(&func_index, "elem expr func index")); ------------------ | | 55| 82| do { \ | | 56| 82| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 82] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 82| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2752| 82| CALLBACK(OnOpcode, Opcode::RefFunc); ------------------ | | 61| 82| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 82|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 82| do { \ | | | | | | 42| 82| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 82] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 82| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 82| #member " callback failed") ------------------ 2753| 82| CALLBACK(OnRefFuncExpr, func_index); ------------------ | | 61| 82| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 82|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 82| do { \ | | | | | | 42| 82| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 5, False: 77] | | | | | | ------------------ | | | | | | 43| 5| PrintError(__VA_ARGS__); \ | | | | | | 44| 5| return Result::Error; \ | | | | | | 45| 5| } \ | | | | | | 46| 82| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 82| #member " callback failed") ------------------ 2754| 77| CALLBACK(OnOpcodeUint32, func_index); ------------------ | | 61| 77| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 77|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 77| do { \ | | | | | | 42| 77| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 77] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 77| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 77| #member " callback failed") ------------------ 2755| 77| CALLBACK0(OnEndExpr); ------------------ | | 58| 77| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 77|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 77| do { \ | | | | | | 42| 77| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 77] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 77| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2756| 77| } 2757| 77| CALLBACK(EndElemExpr, i, j); ------------------ | | 61| 77| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 77|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 77| do { \ | | | | | | 42| 77| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 77] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 77| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 77| #member " callback failed") ------------------ 2758| 77| } 2759| 11| CALLBACK(EndElemSegment, i); ------------------ | | 61| 11| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 11|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 11| do { \ | | | | | | 42| 11| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 11] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 11| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 11| #member " callback failed") ------------------ 2760| 11| } 2761| 17| CALLBACK0(EndElemSection); ------------------ | | 58| 17| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 17|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 17| do { \ | | | | | | 42| 17| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 17] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 17| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2762| 17| return Result::Ok; 2763| 17|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader15ReadCodeSectionEm: 2765| 387|Result BinaryReader::ReadCodeSection(Offset section_size) { 2766| 387| CALLBACK(BeginCodeSection, section_size); ------------------ | | 61| 387| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 387|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 387| do { \ | | | | | | 42| 387| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 387] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 387| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 387| #member " callback failed") ------------------ 2767| 387| CHECK_RESULT(ReadCount(&num_function_bodies_, "function body count")); ------------------ | | 55| 387| do { \ | | 56| 387| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5, False: 382] | | ------------------ | | 57| 5| return ::wabt::Result::Error; \ | | 58| 5| } \ | | 59| 387| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2768| 382| ERROR_UNLESS(num_function_signatures_ == num_function_bodies_, ------------------ | | 48| 382|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 382| do { \ | | | | 42| 382| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 2, False: 380] | | | | ------------------ | | | | 43| 2| PrintError(__VA_ARGS__); \ | | | | 44| 2| return Result::Error; \ | | | | 45| 2| } \ | | | | 46| 382| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2769| 380| "function signature count != function body count"); 2770| 380| CALLBACK(OnFunctionBodyCount, num_function_bodies_); ------------------ | | 61| 380| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 380|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 380| do { \ | | | | | | 42| 380| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 380] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 380| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 380| #member " callback failed") ------------------ 2771| 2.23k| for (Index i = 0; i < num_function_bodies_; ++i) { ------------------ | Branch (2771:21): [True: 2.23k, False: 1] ------------------ 2772| 2.23k| Index func_index = num_func_imports_ + i; 2773| 2.23k| Offset func_offset = state_.offset; 2774| 2.23k| state_.offset = func_offset; 2775| 2.23k| uint32_t body_size; 2776| 2.23k| CHECK_RESULT(ReadU32Leb128(&body_size, "function body size")); ------------------ | | 55| 2.23k| do { \ | | 56| 2.23k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2.23k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2.23k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2777| 2.23k| Offset body_start_offset = state_.offset; 2778| 2.23k| Offset end_offset = body_start_offset + body_size; 2779| 2.23k| CALLBACK(BeginFunctionBody, func_index, body_size); ------------------ | | 61| 2.23k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2.23k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.23k| do { \ | | | | | | 42| 2.23k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2.23k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2.23k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2.23k| #member " callback failed") ------------------ 2780| | 2781| 2.23k| uint64_t total_locals = 0; 2782| 2.23k| Index num_local_decls; 2783| 2.23k| CHECK_RESULT(ReadCount(&num_local_decls, "local declaration count")); ------------------ | | 55| 2.23k| do { \ | | 56| 2.23k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 2.22k] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 2.23k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2784| 2.22k| CALLBACK(OnLocalDeclCount, num_local_decls); ------------------ | | 61| 2.22k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2.22k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2.22k| do { \ | | | | | | 42| 2.22k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2.22k] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2.22k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2.22k| #member " callback failed") ------------------ 2785| 2.32k| for (Index k = 0; k < num_local_decls; ++k) { ------------------ | Branch (2785:23): [True: 101, False: 2.22k] ------------------ 2786| 101| Index num_local_types; 2787| 101| CHECK_RESULT(ReadIndex(&num_local_types, "local type count")); ------------------ | | 55| 101| do { \ | | 56| 101| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 101] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 101| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2788| 101| total_locals += num_local_types; 2789| 101| ERROR_UNLESS(total_locals <= UINT32_MAX, "local count must be <= 0x%x", ------------------ | | 48| 101|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 101| do { \ | | | | 42| 101| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 0, False: 101] | | | | ------------------ | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | 44| 0| return Result::Error; \ | | | | 45| 0| } \ | | | | 46| 101| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2790| 101| UINT32_MAX); 2791| 101| Type local_type; 2792| 101| CHECK_RESULT(ReadType(&local_type, "local type")); ------------------ | | 55| 101| do { \ | | 56| 101| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 101] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 101| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2793| 101| ERROR_UNLESS(IsConcreteType(local_type), "expected valid local type"); ------------------ | | 48| 101|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 101| do { \ | | | | 42| 101| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 8, False: 93] | | | | ------------------ | | | | 43| 8| PrintError(__VA_ARGS__); \ | | | | 44| 8| return Result::Error; \ | | | | 45| 8| } \ | | | | 46| 101| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2794| 93| CALLBACK(OnLocalDecl, k, num_local_types, local_type); ------------------ | | 61| 93| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 93|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 93| do { \ | | | | | | 42| 93| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 93] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 93| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 93| #member " callback failed") ------------------ 2795| 93| } 2796| | 2797| 2.22k| if (options_.skip_function_bodies) { ------------------ | Branch (2797:9): [True: 0, False: 2.22k] ------------------ 2798| 0| state_.offset = end_offset; 2799| 2.22k| } else { 2800| 2.22k| CHECK_RESULT(ReadFunctionBody(end_offset)); ------------------ | | 55| 2.22k| do { \ | | 56| 2.22k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 364, False: 1.85k] | | ------------------ | | 57| 364| return ::wabt::Result::Error; \ | | 58| 364| } \ | | 59| 2.22k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2801| 2.22k| } 2802| | 2803| 1.85k| CALLBACK(EndFunctionBody, func_index); ------------------ | | 61| 1.85k| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1.85k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1.85k| do { \ | | | | | | 42| 1.85k| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 5, False: 1.85k] | | | | | | ------------------ | | | | | | 43| 5| PrintError(__VA_ARGS__); \ | | | | | | 44| 5| return Result::Error; \ | | | | | | 45| 5| } \ | | | | | | 46| 1.85k| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1.85k| #member " callback failed") ------------------ 2804| 1.85k| } 2805| 1| CALLBACK0(EndCodeSection); ------------------ | | 58| 1| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1| do { \ | | | | | | 42| 1| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2806| 1| return Result::Ok; 2807| 1|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader16ReadFunctionBodyEm: 667| 2.22k|Result BinaryReader::ReadFunctionBody(Offset end_offset) { 668| 2.22k| CHECK_RESULT(ReadInstructions(end_offset, "function body")); ------------------ | | 55| 2.22k| do { \ | | 56| 2.22k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 360, False: 1.86k] | | ------------------ | | 57| 360| return ::wabt::Result::Error; \ | | 58| 360| } \ | | 59| 2.22k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 669| 1.86k| ERROR_UNLESS(state_.offset == end_offset, ------------------ | | 48| 1.86k|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 1.86k| do { \ | | | | 42| 1.86k| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 4, False: 1.85k] | | | | ------------------ | | | | 43| 4| PrintError(__VA_ARGS__); \ | | | | 44| 4| return Result::Error; \ | | | | 45| 4| } \ | | | | 46| 1.86k| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 670| 1.85k| "function body shorter than given size"); 671| 1.85k| return Result::Ok; 672| 1.86k|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader15ReadDataSectionEm: 2809| 20|Result BinaryReader::ReadDataSection(Offset section_size) { 2810| 20| CALLBACK(BeginDataSection, section_size); ------------------ | | 61| 20| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 20|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 20| do { \ | | | | | | 42| 20| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 20] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 20| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 20| #member " callback failed") ------------------ 2811| 20| Index num_data_segments; 2812| 20| CHECK_RESULT(ReadCount(&num_data_segments, "data segment count")); ------------------ | | 55| 20| do { \ | | 56| 20| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5, False: 15] | | ------------------ | | 57| 5| return ::wabt::Result::Error; \ | | 58| 5| } \ | | 59| 20| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2813| 15| CALLBACK(OnDataSegmentCount, num_data_segments); ------------------ | | 61| 15| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 15|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 15| do { \ | | | | | | 42| 15| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 15] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 15| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 15| #member " callback failed") ------------------ 2814| | // If the DataCount section is not present, then data_count_ will be invalid. 2815| 15| ERROR_UNLESS(data_count_ == kInvalidIndex || data_count_ == num_data_segments, ------------------ | | 48| 15|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | ------------------ | | | | 41| 15| do { \ | | | | 42| 31| if (expr) { \ | | | | ------------------ | | | | | Branch (42:9): [True: 14, False: 1] | | | | | Branch (42:9): [True: 0, False: 1] | | | | ------------------ | | | | 43| 1| PrintError(__VA_ARGS__); \ | | | | 44| 1| return Result::Error; \ | | | | 45| 1| } \ | | | | 46| 15| } while (0) | | | | ------------------ | | | | | Branch (46:12): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2816| 14| "data segment count does not equal count in DataCount section"); 2817| 30| for (Index i = 0; i < num_data_segments; ++i) { ------------------ | Branch (2817:21): [True: 25, False: 5] ------------------ 2818| 25| uint32_t flags; 2819| 25| CHECK_RESULT(ReadU32Leb128(&flags, "data segment flags")); ------------------ | | 55| 25| do { \ | | 56| 25| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 25] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 25| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2820| 25| ERROR_IF(flags != 0 && !options_.features.bulk_memory_enabled(), ------------------ | | 41| 25| do { \ | | 42| 72| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 22, False: 3] | | | Branch (42:9): [True: 0, False: 22] | | ------------------ | | 43| 0| PrintError(__VA_ARGS__); \ | | 44| 0| return Result::Error; \ | | 45| 0| } \ | | 46| 25| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 2821| 25| "invalid memory index %d: bulk memory not allowed", flags); 2822| 25| ERROR_IF(flags > SegFlagMax, "invalid data segment flags: %#x", flags); ------------------ | | 41| 25| do { \ | | 42| 25| if (expr) { \ | | ------------------ | | | Branch (42:9): [True: 3, False: 22] | | ------------------ | | 43| 3| PrintError(__VA_ARGS__); \ | | 44| 3| return Result::Error; \ | | 45| 3| } \ | | 46| 25| } while (0) | | ------------------ | | | Branch (46:12): [Folded - Ignored] | | ------------------ ------------------ 2823| 22| Index memory_index(0); 2824| 22| if (flags & SegExplicitIndex) { ------------------ | Branch (2824:9): [True: 13, False: 9] ------------------ 2825| 13| CHECK_RESULT(ReadIndex(&memory_index, "data segment memory index")); ------------------ | | 55| 13| do { \ | | 56| 13| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 13] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 13| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2826| 13| } 2827| 22| CALLBACK(BeginDataSegment, i, memory_index, flags); ------------------ | | 61| 22| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 22|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 22| do { \ | | | | | | 42| 22| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 5, False: 17] | | | | | | ------------------ | | | | | | 43| 5| PrintError(__VA_ARGS__); \ | | | | | | 44| 5| return Result::Error; \ | | | | | | 45| 5| } \ | | | | | | 46| 22| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 22| #member " callback failed") ------------------ 2828| 17| if (!(flags & SegPassive)) { ------------------ | Branch (2828:9): [True: 1, False: 16] ------------------ 2829| 1| CALLBACK(BeginDataSegmentInitExpr, i); ------------------ | | 61| 1| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 1|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 1| do { \ | | | | | | 42| 1| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 1| #member " callback failed") ------------------ 2830| 1| CHECK_RESULT(ReadInitExpr(i)); ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 0] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2831| 0| CALLBACK(EndDataSegmentInitExpr, i); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 2832| 0| } 2833| | 2834| 16| Address data_size; 2835| 16| const void* data; 2836| 16| CHECK_RESULT(ReadBytes(&data, &data_size, "data segment data")); ------------------ | | 55| 16| do { \ | | 56| 16| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 16] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 16| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2837| 16| CALLBACK(OnDataSegmentData, i, data, data_size); ------------------ | | 61| 16| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 16|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 16| do { \ | | | | | | 42| 16| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 16] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 16| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 16| #member " callback failed") ------------------ 2838| 16| CALLBACK(EndDataSegment, i); ------------------ | | 61| 16| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 16|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 16| do { \ | | | | | | 42| 16| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 16] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 16| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 16| #member " callback failed") ------------------ 2839| 16| } 2840| 5| CALLBACK0(EndDataSection); ------------------ | | 58| 5| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 5|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 5| do { \ | | | | | | 42| 5| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 5] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 5| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2841| 5| return Result::Ok; 2842| 5|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader14ReadTagSectionEm: 2327| 9|Result BinaryReader::ReadTagSection(Offset section_size) { 2328| 9| CALLBACK(BeginTagSection, section_size); ------------------ | | 61| 9| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 9|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 9| do { \ | | | | | | 42| 9| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 9] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 9| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 9| #member " callback failed") ------------------ 2329| 9| Index num_tags; 2330| 9| CHECK_RESULT(ReadCount(&num_tags, "tag count")); ------------------ | | 55| 9| do { \ | | 56| 9| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 8] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 9| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2331| 8| CALLBACK(OnTagCount, num_tags); ------------------ | | 61| 8| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 8|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 8| do { \ | | | | | | 42| 8| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 8] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 8| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 8| #member " callback failed") ------------------ 2332| | 2333| 8| for (Index i = 0; i < num_tags; ++i) { ------------------ | Branch (2333:21): [True: 8, False: 0] ------------------ 2334| 8| Index tag_index = num_tag_imports_ + i; 2335| 8| Index sig_index; 2336| 8| CHECK_RESULT(ReadTagType(&sig_index)); ------------------ | | 55| 8| do { \ | | 56| 8| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 4, False: 4] | | ------------------ | | 57| 4| return ::wabt::Result::Error; \ | | 58| 4| } \ | | 59| 8| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2337| 4| CALLBACK(OnTagType, tag_index, sig_index); ------------------ | | 61| 4| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 4|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 4| do { \ | | | | | | 42| 4| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 43| 4| PrintError(__VA_ARGS__); \ | | | | | | 44| 4| return Result::Error; \ | | | | | | 45| 4| } \ | | | | | | 46| 4| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 4| #member " callback failed") ------------------ 2338| 4| } 2339| | 2340| 0| CALLBACK(EndTagSection); ------------------ | | 61| 0| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 0|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 0| do { \ | | | | | | 42| 0| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 0| #member " callback failed") ------------------ 2341| 0| return Result::Ok; 2342| 0|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader20ReadDataCountSectionEm: 2844| 2|Result BinaryReader::ReadDataCountSection(Offset section_size) { 2845| 2| CALLBACK(BeginDataCountSection, section_size); ------------------ | | 61| 2| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2| do { \ | | | | | | 42| 2| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2| #member " callback failed") ------------------ 2846| 2| Index data_count; 2847| 2| CHECK_RESULT(ReadIndex(&data_count, "data count")); ------------------ | | 55| 2| do { \ | | 56| 2| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 2848| 2| CALLBACK(OnDataCount, data_count); ------------------ | | 61| 2| ERROR_UNLESS(Succeeded(delegate_->member(__VA_ARGS__)), \ | | ------------------ | | | | 48| 2|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2| do { \ | | | | | | 42| 2| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 62| 2| #member " callback failed") ------------------ 2849| 2| CALLBACK0(EndDataCountSection); ------------------ | | 58| 2| ERROR_UNLESS(Succeeded(delegate_->member()), #member " callback failed") | | ------------------ | | | | 48| 2|#define ERROR_UNLESS(expr, ...) ERROR_IF(!(expr), __VA_ARGS__) | | | | ------------------ | | | | | | 41| 2| do { \ | | | | | | 42| 2| if (expr) { \ | | | | | | ------------------ | | | | | | | Branch (42:9): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 43| 0| PrintError(__VA_ARGS__); \ | | | | | | 44| 0| return Result::Error; \ | | | | | | 45| 0| } \ | | | | | | 46| 2| } while (0) | | | | | | ------------------ | | | | | | | Branch (46:12): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2850| 2| data_count_ = data_count; 2851| 2| return Result::Ok; 2852| 2|} binary-reader.cc:_ZN4wabt12_GLOBAL__N_112BinaryReader17ValueRestoreGuardImXadL_ZNS1_9read_end_EEEED2Ev: 86| 2.26M| ~ValueRestoreGuard() { this_->*member = previous_value_; } _ZN4wabt15GetSectionOrderENS_13BinarySectionE: 21| 3.42k|BinarySectionOrder GetSectionOrder(BinarySection sec) { 22| 3.42k| switch (sec) { 23| 0|#define V(Name, name, code) \ 24| 0| case BinarySection::Name: \ 25| 0| return BinarySectionOrder::Name; 26| 0| WABT_FOREACH_BINARY_SECTION(V) ------------------ | | 40| 0| V(Custom, custom, 0) \ | | ------------------ | | | | 26| 0| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 0| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 0, False: 3.42k] | | | | | | ------------------ | | | | | | 25| 0| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 41| 509| V(Type, type, 1) \ | | ------------------ | | | | 26| 509| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 509| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 509, False: 2.91k] | | | | | | ------------------ | | | | | | 25| 509| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 42| 509| V(Import, import, 2) \ | | ------------------ | | | | 26| 65| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 65| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 65, False: 3.35k] | | | | | | ------------------ | | | | | | 25| 65| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 43| 843| V(Function, function, 3) \ | | ------------------ | | | | 26| 843| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 843| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 843, False: 2.57k] | | | | | | ------------------ | | | | | | 25| 843| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 44| 843| V(Table, table, 4) \ | | ------------------ | | | | 26| 306| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 306| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 306, False: 3.11k] | | | | | | ------------------ | | | | | | 25| 306| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 45| 534| V(Memory, memory, 5) \ | | ------------------ | | | | 26| 534| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 534| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 534, False: 2.88k] | | | | | | ------------------ | | | | | | 25| 534| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 46| 534| V(Tag, tag, 13) \ | | ------------------ | | | | 26| 12| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 12| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 12, False: 3.41k] | | | | | | ------------------ | | | | | | 25| 12| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 47| 112| V(Global, global, 6) \ | | ------------------ | | | | 26| 112| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 112| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 112, False: 3.31k] | | | | | | ------------------ | | | | | | 25| 112| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 48| 548| V(Export, export, 7) \ | | ------------------ | | | | 26| 548| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 548| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 548, False: 2.87k] | | | | | | ------------------ | | | | | | 25| 548| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 49| 548| V(Start, start, 8) \ | | ------------------ | | | | 26| 16| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 16| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 16, False: 3.40k] | | | | | | ------------------ | | | | | | 25| 16| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 50| 55| V(Elem, elem, 9) \ | | ------------------ | | | | 26| 55| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 55| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 55, False: 3.36k] | | | | | | ------------------ | | | | | | 25| 55| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 51| 55| V(DataCount, data_count, 12) \ | | ------------------ | | | | 26| 4| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 4| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 4, False: 3.41k] | | | | | | ------------------ | | | | | | 25| 4| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 52| 398| V(Code, code, 10) \ | | ------------------ | | | | 26| 398| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 398| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 398, False: 3.02k] | | | | | | ------------------ | | | | | | 25| 398| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ | | 53| 398| V(Data, data, 11) | | ------------------ | | | | 26| 20| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 24| 20| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (24:3): [True: 20, False: 3.40k] | | | | | | ------------------ | | | | | | 25| 20| return BinarySectionOrder::Name; | | | | ------------------ | | ------------------ ------------------ 27| 0|#undef V 28| 0| default: ------------------ | Branch (28:5): [True: 0, False: 3.42k] ------------------ 29| 0| WABT_UNREACHABLE; ------------------ | | 112| 0|#define WABT_UNREACHABLE abort() ------------------ 30| 3.42k| } 31| 3.42k|} _ZN4wabt14GetSectionNameENS_13BinarySectionE: 33| 112|const char* GetSectionName(BinarySection sec) { 34| 112| switch (sec) { 35| 0|#define V(Name, name, code) \ 36| 0| case BinarySection::Name: \ 37| 0| return #Name; 38| 0| WABT_FOREACH_BINARY_SECTION(V) ------------------ | | 40| 0| V(Custom, custom, 0) \ | | ------------------ | | | | 38| 0| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 0| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 0, False: 112] | | | | | | ------------------ | | | | | | 37| 0| return #Name; | | | | ------------------ | | ------------------ | | 41| 37| V(Type, type, 1) \ | | ------------------ | | | | 38| 37| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 37| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 37, False: 75] | | | | | | ------------------ | | | | | | 37| 37| return #Name; | | | | ------------------ | | ------------------ | | 42| 37| V(Import, import, 2) \ | | ------------------ | | | | 38| 18| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 18| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 18, False: 94] | | | | | | ------------------ | | | | | | 37| 18| return #Name; | | | | ------------------ | | ------------------ | | 43| 18| V(Function, function, 3) \ | | ------------------ | | | | 38| 6| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 6| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 6, False: 106] | | | | | | ------------------ | | | | | | 37| 6| return #Name; | | | | ------------------ | | ------------------ | | 44| 8| V(Table, table, 4) \ | | ------------------ | | | | 38| 8| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 8| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 8, False: 104] | | | | | | ------------------ | | | | | | 37| 8| return #Name; | | | | ------------------ | | ------------------ | | 45| 8| V(Memory, memory, 5) \ | | ------------------ | | | | 38| 6| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 6| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 6, False: 106] | | | | | | ------------------ | | | | | | 37| 6| return #Name; | | | | ------------------ | | ------------------ | | 46| 6| V(Tag, tag, 13) \ | | ------------------ | | | | 38| 1| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 1| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 1, False: 111] | | | | | | ------------------ | | | | | | 37| 1| return #Name; | | | | ------------------ | | ------------------ | | 47| 6| V(Global, global, 6) \ | | ------------------ | | | | 38| 6| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 6| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 6, False: 106] | | | | | | ------------------ | | | | | | 37| 6| return #Name; | | | | ------------------ | | ------------------ | | 48| 18| V(Export, export, 7) \ | | ------------------ | | | | 38| 18| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 18| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 18, False: 94] | | | | | | ------------------ | | | | | | 37| 18| return #Name; | | | | ------------------ | | ------------------ | | 49| 18| V(Start, start, 8) \ | | ------------------ | | | | 38| 4| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 4| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 4, False: 108] | | | | | | ------------------ | | | | | | 37| 4| return #Name; | | | | ------------------ | | ------------------ | | 50| 4| V(Elem, elem, 9) \ | | ------------------ | | | | 38| 3| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 3| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 3, False: 109] | | | | | | ------------------ | | | | | | 37| 3| return #Name; | | | | ------------------ | | ------------------ | | 51| 3| V(DataCount, data_count, 12) \ | | ------------------ | | | | 38| 1| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 1| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 1, False: 111] | | | | | | ------------------ | | | | | | 37| 1| return #Name; | | | | ------------------ | | ------------------ | | 52| 3| V(Code, code, 10) \ | | ------------------ | | | | 38| 3| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 3| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 3, False: 109] | | | | | | ------------------ | | | | | | 37| 3| return #Name; | | | | ------------------ | | ------------------ | | 53| 3| V(Data, data, 11) | | ------------------ | | | | 38| 1| WABT_FOREACH_BINARY_SECTION(V) | | | | ------------------ | | | | | | 36| 1| case BinarySection::Name: \ | | | | | | ------------------ | | | | | | | Branch (36:3): [True: 1, False: 111] | | | | | | ------------------ | | | | | | 37| 1| return #Name; | | | | ------------------ | | ------------------ ------------------ 39| 0|#undef V 40| 0| default: ------------------ | Branch (40:5): [True: 0, False: 112] ------------------ 41| 0| WABT_UNREACHABLE; ------------------ | | 112| 0|#define WABT_UNREACHABLE abort() ------------------ 42| 112| } 43| 112|} _ZN4wabt8Features18UpdateDependenciesEv: 39| 7.71k|void Features::UpdateDependencies() { 40| | // Exception handling requires reference types. 41| 7.71k| if (exceptions_enabled_) { ------------------ | Branch (41:7): [True: 4.59k, False: 3.12k] ------------------ 42| 4.59k| reference_types_enabled_ = true; 43| 4.59k| } 44| | 45| | // Function references require reference types. 46| 7.71k| if (function_references_enabled_) { ------------------ | Branch (46:7): [True: 2.83k, False: 4.88k] ------------------ 47| 2.83k| reference_types_enabled_ = true; 48| 2.83k| } 49| | 50| | // Reference types requires bulk memory. 51| 7.71k| if (!bulk_memory_enabled_) { ------------------ | Branch (51:7): [True: 0, False: 7.71k] ------------------ 52| 0| reference_types_enabled_ = false; 53| 0| } 54| 7.71k|} _ZN4wabt6interp16ReadBinaryInterpENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPKvmRKNS_17ReadBinaryOptionsEPNS1_6vectorINS_5ErrorENS1_9allocatorISC_EEEEPNS0_10ModuleDescE: 1612| 981| ModuleDesc* out_module) { 1613| 981| BinaryReaderInterp reader(out_module, filename, errors, options.features); 1614| 981| return ReadBinary(data, size, &reader, options); 1615| 981|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterpC2EPNS0_10ModuleDescENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEPNS5_6vectorINS_5ErrorENS5_9allocatorISB_EEEERKNS_8FeaturesE: 380| 981| filename_(filename) {} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp7OnErrorERKNS_5ErrorE: 480| 2.12M|bool BinaryReaderInterp::OnError(const Error& error) { 481| 2.12M| errors_->push_back(error); 482| 2.12M| return true; 483| 2.12M|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp9EndModuleEv: 485| 34|Result BinaryReaderInterp::EndModule() { 486| 34| CHECK_RESULT(validator_.EndModule()); ------------------ | | 55| 34| do { \ | | 56| 34| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 34] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 34| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 487| 34| return Result::Ok; 488| 34|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11OnTypeCountEj: 490| 455|Result BinaryReaderInterp::OnTypeCount(Index count) { 491| 455| module_.func_types.reserve(count); 492| 455| return Result::Ok; 493| 455|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp10OnFuncTypeEjjPNS_4TypeEjS4_: 499| 1.47k| Type* result_types) { 500| 1.47k| CHECK_RESULT(validator_.OnFuncType(GetLocation(), param_count, param_types, ------------------ | | 55| 1.47k| do { \ | | 56| 1.47k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.47k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.47k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 501| 1.47k| result_count, result_types, index)); 502| 1.47k| module_.func_types.push_back(FuncType(ToInterp(param_count, param_types), 503| 1.47k| ToInterp(result_count, result_types))); 504| 1.47k| return Result::Ok; 505| 1.47k|} binary-reader-interp.cc:_ZNK4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11GetLocationEv: 346| 426k|Location BinaryReaderInterp::GetLocation() const { 347| 426k| Location loc; 348| 426k| loc.filename = filename_; 349| 426k| loc.offset = state->offset; 350| 426k| return loc; 351| 426k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_18ToInterpEjPNS_4TypeE: 33| 2.94k|ValueTypes ToInterp(Index count, Type* types) { 34| 2.94k| return ValueTypes(&types[0], &types[count]); 35| 2.94k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp12OnImportFuncEjNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEES7_jj: 511| 1.54k| Index sig_index) { 512| 1.54k| CHECK_RESULT( ------------------ | | 55| 1.54k| do { \ | | 56| 1.54k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 6, False: 1.53k] | | ------------------ | | 57| 6| return ::wabt::Result::Error; \ | | 58| 6| } \ | | 59| 1.54k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 513| 1.54k| validator_.OnFunction(GetLocation(), Var(sig_index, GetLocation()))); 514| 1.53k| FuncType& func_type = module_.func_types[sig_index]; 515| 1.53k| module_.imports.push_back(ImportDesc{ImportType( 516| 1.53k| std::string(module_name), std::string(field_name), func_type.Clone())}); 517| 1.53k| func_types_.push_back(func_type); 518| 1.53k| return Result::Ok; 519| 1.54k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnImportGlobalEjNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEES7_jNS_4TypeEb: 553| 20| bool mutable_) { 554| 20| CHECK_RESULT(validator_.OnGlobalImport(GetLocation(), type, mutable_)); ------------------ | | 55| 20| do { \ | | 56| 20| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 20] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 20| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 555| 20| GlobalType global_type{type, ToMutability(mutable_)}; 556| 20| module_.imports.push_back(ImportDesc{ImportType( 557| 20| std::string(module_name), std::string(field_name), global_type.Clone())}); 558| 20| global_types_.push_back(global_type); 559| 20| return Result::Ok; 560| 20|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_112ToMutabilityEb: 37| 242|Mutability ToMutability(bool mut) { 38| 242| return mut ? Mutability::Var : Mutability::Const; ------------------ | Branch (38:10): [True: 90, False: 152] ------------------ 39| 242|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11OnImportTagEjNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEES7_jj: 566| 3| Index sig_index) { 567| 3| CHECK_RESULT(validator_.OnTag(GetLocation(), Var(sig_index, GetLocation()))); ------------------ | | 55| 3| do { \ | | 56| 3| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 3] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 3| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 568| 3| FuncType& func_type = module_.func_types[sig_index]; 569| 3| TagType tag_type{TagAttr::Exception, func_type.params}; 570| 3| module_.imports.push_back(ImportDesc{ImportType( 571| 3| std::string(module_name), std::string(field_name), tag_type.Clone())}); 572| 3| tag_types_.push_back(tag_type); 573| 3| return Result::Ok; 574| 3|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp15OnFunctionCountEj: 576| 433|Result BinaryReaderInterp::OnFunctionCount(Index count) { 577| 433| module_.funcs.reserve(count); 578| 433| return Result::Ok; 579| 433|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp10OnFunctionEjj: 581| 7.54k|Result BinaryReaderInterp::OnFunction(Index index, Index sig_index) { 582| 7.54k| CHECK_RESULT( ------------------ | | 55| 7.54k| do { \ | | 56| 7.54k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 52, False: 7.48k] | | ------------------ | | 57| 52| return ::wabt::Result::Error; \ | | 58| 52| } \ | | 59| 7.54k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 583| 7.54k| validator_.OnFunction(GetLocation(), Var(sig_index, GetLocation()))); 584| 7.48k| FuncType& func_type = module_.func_types[sig_index]; 585| 7.48k| module_.funcs.push_back(FuncDesc{func_type, {}, Istream::kInvalidOffset, {}}); 586| 7.48k| func_types_.push_back(func_type); 587| 7.48k| return Result::Ok; 588| 7.54k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp12OnTableCountEj: 590| 147|Result BinaryReaderInterp::OnTableCount(Index count) { 591| 147| module_.tables.reserve(count); 592| 147| return Result::Ok; 593| 147|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp7OnTableEjNS_4TypeEPKNS_6LimitsE: 597| 146| const Limits* elem_limits) { 598| 146| CHECK_RESULT(validator_.OnTable(GetLocation(), elem_type, *elem_limits)); ------------------ | | 55| 146| do { \ | | 56| 146| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 146] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 146| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 599| 146| TableType table_type{elem_type, *elem_limits}; 600| 146| module_.tables.push_back(TableDesc{table_type}); 601| 146| table_types_.push_back(table_type); 602| 146| return Result::Ok; 603| 146|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13OnMemoryCountEj: 605| 270|Result BinaryReaderInterp::OnMemoryCount(Index count) { 606| 270| module_.memories.reserve(count); 607| 270| return Result::Ok; 608| 270|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp8OnMemoryEjPKNS_6LimitsE: 610| 343|Result BinaryReaderInterp::OnMemory(Index index, const Limits* limits) { 611| 343| CHECK_RESULT(validator_.OnMemory(GetLocation(), *limits)); ------------------ | | 55| 343| do { \ | | 56| 343| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 3, False: 340] | | ------------------ | | 57| 3| return ::wabt::Result::Error; \ | | 58| 3| } \ | | 59| 343| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 612| 340| MemoryType memory_type{*limits}; 613| 340| module_.memories.push_back(MemoryDesc{memory_type}); 614| 340| memory_types_.push_back(memory_type); 615| 340| return Result::Ok; 616| 343|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13OnGlobalCountEj: 618| 71|Result BinaryReaderInterp::OnGlobalCount(Index count) { 619| 71| module_.globals.reserve(count); 620| 71| return Result::Ok; 621| 71|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11BeginGlobalEjNS_4TypeEb: 623| 222|Result BinaryReaderInterp::BeginGlobal(Index index, Type type, bool mutable_) { 624| 222| CHECK_RESULT(validator_.OnGlobal(GetLocation(), type, mutable_)); ------------------ | | 55| 222| do { \ | | 56| 222| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 222] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 222| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 625| 222| GlobalType global_type{type, ToMutability(mutable_)}; 626| 222| FuncDesc init_func{FuncType{{}, {type}}, {}, Istream::kInvalidOffset, {}}; 627| 222| module_.globals.push_back(GlobalDesc{global_type, init_func}); 628| 222| global_types_.push_back(global_type); 629| 222| return Result::Ok; 630| 222|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp19BeginGlobalInitExprEj: 632| 222|Result BinaryReaderInterp::BeginGlobalInitExpr(Index index) { 633| 222| GlobalDesc& global = module_.globals.back(); 634| 222| return BeginInitExpr(&global.init_func); 635| 222|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13BeginInitExprEPNS0_8FuncDescE: 645| 320|Result BinaryReaderInterp::BeginInitExpr(FuncDesc* func) { 646| 320| label_stack_.clear(); 647| 320| func_ = func; 648| 320| func_->code_offset = istream_.end(); 649| 320| Type type = func->type.results[0]; 650| 320| CHECK_RESULT(validator_.BeginInitExpr(GetLocation(), type)); ------------------ | | 55| 320| do { \ | | 56| 320| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 320] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 320| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 651| | // Push implicit init func label (equivalent to return). 652| 320| PushLabel(LabelKind::Try, Istream::kInvalidOffset, Istream::kInvalidOffset); 653| 320| return Result::Ok; 654| 320|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp9PushLabelENS1_9LabelKindEjjj: 808| 5.54k| u32 handler_desc_index) { 809| 5.54k| label_stack_.push_back(Label{kind, offset, fixup_offset, handler_desc_index}); 810| 5.54k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp17EndGlobalInitExprEj: 656| 189|Result BinaryReaderInterp::EndGlobalInitExpr(Index index) { 657| 189| return EndInitExpr(); 658| 189|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11EndInitExprEv: 637| 281|Result BinaryReaderInterp::EndInitExpr() { 638| 281| FixupTopLabel(); 639| 281| CHECK_RESULT(validator_.EndInitExpr()); ------------------ | | 55| 281| do { \ | | 56| 281| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 281] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 281| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 640| 281| istream_.Emit(Opcode::Return); 641| 281| PopLabel(); 642| 281| return Result::Ok; 643| 281|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13FixupTopLabelEv: 467| 2.91k|void BinaryReaderInterp::FixupTopLabel() { 468| 2.91k| depth_fixups_.Resolve(istream_, label_stack_.size() - 1); 469| 2.91k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_18FixupMap7ResolveERNS0_7IstreamEj: 361| 5.14k|void FixupMap::Resolve(Istream& istream, Index index) { 362| 5.14k| auto iter = map.find(index); 363| 5.14k| if (iter == map.end()) { ------------------ | Branch (363:7): [True: 5.02k, False: 113] ------------------ 364| 5.02k| return; 365| 5.02k| } 366| 147| for (Offset offset : iter->second) { ------------------ | Branch (366:22): [True: 147, False: 113] ------------------ 367| 147| istream.ResolveFixupU32(offset); 368| 147| } 369| 113| map.erase(iter); 370| 113|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp8PopLabelEv: 812| 2.90k|void BinaryReaderInterp::PopLabel() { 813| 2.90k| label_stack_.pop_back(); 814| 2.90k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp8OnExportEjNS_12ExternalKindEjNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE: 677| 2.03k| std::string_view name) { 678| 2.03k| CHECK_RESULT(validator_.OnExport(GetLocation(), kind, ------------------ | | 55| 2.03k| do { \ | | 56| 2.03k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 30, False: 2.00k] | | ------------------ | | 57| 30| return ::wabt::Result::Error; \ | | 58| 30| } \ | | 59| 2.03k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 679| 2.03k| Var(item_index, GetLocation()), name)); 680| | 681| 2.00k| std::unique_ptr type; 682| 2.00k| switch (kind) { ------------------ | Branch (682:11): [True: 0, False: 2.00k] ------------------ 683| 2.00k| case ExternalKind::Func: type = func_types_[item_index].Clone(); break; ------------------ | Branch (683:5): [True: 2.00k, False: 6] ------------------ 684| 0| case ExternalKind::Table: type = table_types_[item_index].Clone(); break; ------------------ | Branch (684:5): [True: 0, False: 2.00k] ------------------ 685| 2| case ExternalKind::Memory: type = memory_types_[item_index].Clone(); break; ------------------ | Branch (685:5): [True: 2, False: 2.00k] ------------------ 686| 4| case ExternalKind::Global: type = global_types_[item_index].Clone(); break; ------------------ | Branch (686:5): [True: 4, False: 2.00k] ------------------ 687| 0| case ExternalKind::Tag: type = tag_types_[item_index].Clone(); break; ------------------ | Branch (687:5): [True: 0, False: 2.00k] ------------------ 688| 2.00k| } 689| 2.00k| module_.exports.push_back( 690| 2.00k| ExportDesc{ExportType(std::string(name), std::move(type)), item_index}); 691| 2.00k| return Result::Ok; 692| 2.00k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp15OnStartFunctionEj: 694| 9|Result BinaryReaderInterp::OnStartFunction(Index func_index) { 695| 9| CHECK_RESULT( ------------------ | | 55| 9| do { \ | | 56| 9| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 9, False: 0] | | ------------------ | | 57| 9| return ::wabt::Result::Error; \ | | 58| 9| } \ | | 59| 9| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 696| 9| validator_.OnStart(GetLocation(), Var(func_index, GetLocation()))); 697| 0| module_.starts.push_back(StartDesc{func_index}); 698| 0| return Result::Ok; 699| 9|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp17BeginFunctionBodyEjm: 816| 2.23k|Result BinaryReaderInterp::BeginFunctionBody(Index index, Offset size) { 817| 2.23k| Index defined_index = index - num_func_imports(); 818| 2.23k| func_ = &module_.funcs[defined_index]; 819| 2.23k| func_->code_offset = istream_.end(); 820| | 821| 2.23k| depth_fixups_.Clear(); 822| 2.23k| label_stack_.clear(); 823| | 824| 2.23k| func_fixups_.Resolve(istream_, defined_index); 825| | 826| 2.23k| CHECK_RESULT(validator_.BeginFunctionBody(GetLocation(), index)); ------------------ | | 55| 2.23k| do { \ | | 56| 2.23k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2.23k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2.23k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 827| | 828| | // Push implicit func label (equivalent to return). 829| | // With exception handling it acts as a catch-less try block, which is 830| | // needed to support delegating to the caller of a function using the 831| | // try-delegate instruction. 832| 2.23k| PushLabel(LabelKind::Try, Istream::kInvalidOffset, Istream::kInvalidOffset, 833| 2.23k| func_->handlers.size()); 834| 2.23k| func_->handlers.push_back(HandlerDesc{HandlerKind::Catch, 835| 2.23k| istream_.end(), 836| 2.23k| Istream::kInvalidOffset, 837| 2.23k| {}, 838| 2.23k| {Istream::kInvalidOffset}, 839| 2.23k| static_cast(func_->locals.size()), 840| 2.23k| 0}); 841| 2.23k| return Result::Ok; 842| 2.23k|} binary-reader-interp.cc:_ZNK4wabt6interp12_GLOBAL__N_118BinaryReaderInterp16num_func_importsEv: 876| 2.87k|Index BinaryReaderInterp::num_func_imports() const { 877| 2.87k| return func_types_.size() - module_.funcs.size(); 878| 2.87k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_18FixupMap5ClearEv: 353| 2.23k|void FixupMap::Clear() { 354| 2.23k| map.clear(); 355| 2.23k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp16OnLocalDeclCountEj: 856| 2.22k|Result BinaryReaderInterp::OnLocalDeclCount(Index count) { 857| 2.22k| local_decl_count_ = count; 858| 2.22k| local_count_ = 0; 859| 2.22k| return Result::Ok; 860| 2.22k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11OnLocalDeclEjjNS_4TypeE: 864| 93| Type type) { 865| 93| CHECK_RESULT(validator_.OnLocalDecl(GetLocation(), count, type)); ------------------ | | 55| 93| do { \ | | 56| 93| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 93] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 93| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 866| | 867| 93| local_count_ += count; 868| 93| func_->locals.push_back(LocalDesc{type, count, local_count_}); 869| | 870| 93| if (decl_index == local_decl_count_ - 1) { ------------------ | Branch (870:7): [True: 86, False: 7] ------------------ 871| 86| istream_.Emit(Opcode::InterpAlloca, local_count_); 872| 86| } 873| 93| return Result::Ok; 874| 93|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp8OnOpcodeENS_6OpcodeE: 880| 379k|Result BinaryReaderInterp::OnOpcode(Opcode opcode) { 881| 379k| if (func_ == nullptr || label_stack_.empty()) { ------------------ | Branch (881:7): [True: 0, False: 379k] | Branch (881:27): [True: 0, False: 379k] ------------------ 882| 0| PrintError("Unexpected instruction after end of function"); 883| 0| return Result::Error; 884| 0| } 885| 379k| return Result::Ok; 886| 379k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_112GetAlignmentEm: 906| 5.74k|uint32_t GetAlignment(Address alignment_log2) { 907| 5.74k| return alignment_log2 < 32 ? 1 << alignment_log2 : ~0u; ------------------ | Branch (907:10): [True: 5.74k, False: 6] ------------------ 908| 5.74k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp17OnAtomicStoreExprENS_6OpcodeEjmm: 976| 1| Address offset) { 977| 1| CHECK_RESULT(validator_.OnAtomicStore(GetLocation(), opcode, ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 978| 1| Var(memidx, GetLocation()), 979| 1| GetAlignment(align_log2), offset)); 980| 1| istream_.Emit(opcode, memidx, offset); 981| 1| return Result::Ok; 982| 1|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp15OnAtomicRmwExprENS_6OpcodeEjmm: 987| 15| Address offset) { 988| 15| CHECK_RESULT(validator_.OnAtomicRmw(GetLocation(), opcode, ------------------ | | 55| 15| do { \ | | 56| 15| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 15] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 15| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 989| 15| Var(memidx, GetLocation()), 990| 15| GetAlignment(align_log2), offset)); 991| 15| istream_.Emit(opcode, memidx, offset); 992| 15| return Result::Ok; 993| 15|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp17OnAtomicFenceExprEj: 1413| 234|Result BinaryReaderInterp::OnAtomicFenceExpr(uint32_t consistency_model) { 1414| 234| CHECK_RESULT(validator_.OnAtomicFence(GetLocation(), consistency_model)); ------------------ | | 55| 234| do { \ | | 56| 234| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 234] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 234| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1415| 234| istream_.Emit(Opcode::AtomicFence, consistency_model); 1416| 234| return Result::Ok; 1417| 234|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp18OnAtomicNotifyExprENS_6OpcodeEjmm: 1422| 1| Address offset) { 1423| 1| CHECK_RESULT(validator_.OnAtomicNotify(GetLocation(), opcode, ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 0] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1424| 1| Var(memidx, GetLocation()), 1425| 1| GetAlignment(align_log2), offset)); 1426| 0| istream_.Emit(opcode, memidx, offset); 1427| 0| return Result::Ok; 1428| 1|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp12OnBinaryExprENS_6OpcodeE: 1006| 43.9k|Result BinaryReaderInterp::OnBinaryExpr(Opcode opcode) { 1007| 43.9k| CHECK_RESULT(validator_.OnBinary(GetLocation(), opcode)); ------------------ | | 55| 43.9k| do { \ | | 56| 43.9k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 11, False: 43.9k] | | ------------------ | | 57| 11| return ::wabt::Result::Error; \ | | 58| 11| } \ | | 59| 43.9k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1008| 43.9k| istream_.Emit(opcode); 1009| 43.9k| return Result::Ok; 1010| 43.9k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11OnBlockExprENS_4TypeE: 1012| 1.84k|Result BinaryReaderInterp::OnBlockExpr(Type sig_type) { 1013| 1.84k| CHECK_RESULT(validator_.OnBlock(GetLocation(), sig_type)); ------------------ | | 55| 1.84k| do { \ | | 56| 1.84k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 7, False: 1.84k] | | ------------------ | | 57| 7| return ::wabt::Result::Error; \ | | 58| 7| } \ | | 59| 1.84k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1014| 1.84k| PushLabel(); 1015| 1.84k| return Result::Ok; 1016| 1.84k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp8OnBrExprEj: 1067| 481|Result BinaryReaderInterp::OnBrExpr(Index depth) { 1068| 481| Index drop_count, keep_count, catch_drop_count; 1069| 481| CHECK_RESULT(GetBrDropKeepCount(depth, &drop_count, &keep_count)); ------------------ | | 55| 481| do { \ | | 56| 481| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5, False: 476] | | ------------------ | | 57| 5| return ::wabt::Result::Error; \ | | 58| 5| } \ | | 59| 481| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1070| 476| CHECK_RESULT(validator_.GetCatchCount(depth, &catch_drop_count)); ------------------ | | 55| 476| do { \ | | 56| 476| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 476] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 476| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1071| 476| CHECK_RESULT(validator_.OnBr(GetLocation(), Var(depth, GetLocation()))); ------------------ | | 55| 476| do { \ | | 56| 476| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 476] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 476| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1072| 476| EmitBr(depth, drop_count, keep_count, catch_drop_count); 1073| 476| return Result::Ok; 1074| 476|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp18GetBrDropKeepCountEjPjS3_: 422| 7.60k| Index* out_keep_count) { 423| 7.60k| SharedValidator::Label* label; 424| 7.60k| CHECK_RESULT(validator_.GetLabel(depth, &label)); ------------------ | | 55| 7.60k| do { \ | | 56| 7.60k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5, False: 7.60k] | | ------------------ | | 57| 5| return ::wabt::Result::Error; \ | | 58| 5| } \ | | 59| 7.60k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 425| 7.60k| Index keep_count = label->br_types().size(); 426| 7.60k| CHECK_RESULT( ------------------ | | 55| 7.60k| do { \ | | 56| 7.60k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 7.60k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 7.60k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 427| 7.60k| GetDropCount(keep_count, label->type_stack_limit, out_drop_count)); 428| 7.60k| *out_keep_count = keep_count; 429| 7.60k| return Result::Ok; 430| 7.60k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp12GetDropCountEjmPj: 409| 7.71k| Index* out_drop_count) { 410| 7.71k| assert(validator_.type_stack_size() >= type_stack_limit); 411| 7.71k| Index type_stack_count = validator_.type_stack_size() - type_stack_limit; 412| | // The keep_count may be larger than the type_stack_count if the typechecker 413| | // is currently unreachable. In that case, it doesn't matter what value we 414| | // drop, but 0 is a reasonable choice. 415| 7.71k| *out_drop_count = 416| 7.71k| type_stack_count >= keep_count ? type_stack_count - keep_count : 0; ------------------ | Branch (416:7): [True: 7.16k, False: 544] ------------------ 417| 7.71k| return Result::Ok; 418| 7.71k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp6EmitBrEjjjj: 454| 4.01k| Index catch_drop_count) { 455| 4.01k| istream_.EmitDropKeep(drop_count, keep_count); 456| 4.01k| istream_.EmitCatchDrop(catch_drop_count); 457| 4.01k| Istream::Offset offset = GetLabel(depth)->offset; 458| 4.01k| istream_.Emit(Opcode::Br); 459| 4.01k| if (offset == Istream::kInvalidOffset) { ------------------ | Branch (459:7): [True: 3.22k, False: 791] ------------------ 460| | // depth_fixups_ stores the depth counting up from zero, where zero is the 461| | // top-level function scope. 462| 3.22k| depth_fixups_.Append(label_stack_.size() - 1 - depth, istream_.end()); 463| 3.22k| } 464| 4.01k| istream_.Emit(offset); 465| 4.01k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp8GetLabelEj: 382| 4.42k|Label* BinaryReaderInterp::GetLabel(Index depth) { 383| 4.42k| assert(depth < label_stack_.size()); 384| 4.42k| return &label_stack_[label_stack_.size() - depth - 1]; 385| 4.42k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_18FixupMap6AppendEjj: 357| 3.22k|void FixupMap::Append(Index index, Offset offset) { 358| 3.22k| map[index].push_back(offset); 359| 3.22k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp10OnBrIfExprEj: 1076| 48|Result BinaryReaderInterp::OnBrIfExpr(Index depth) { 1077| 48| Index drop_count, keep_count, catch_drop_count; 1078| 48| CHECK_RESULT(validator_.OnBrIf(GetLocation(), Var(depth, GetLocation()))); ------------------ | | 55| 48| do { \ | | 56| 48| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 47] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 48| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1079| 47| CHECK_RESULT(GetBrDropKeepCount(depth, &drop_count, &keep_count)); ------------------ | | 55| 47| do { \ | | 56| 47| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 47] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 47| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1080| 47| CHECK_RESULT(validator_.GetCatchCount(depth, &catch_drop_count)); ------------------ | | 55| 47| do { \ | | 56| 47| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 47] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 47| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1081| | // Flip the br_if so if is true it can drop values from the stack. 1082| 47| istream_.Emit(Opcode::InterpBrUnless); 1083| 47| auto fixup = istream_.EmitFixupU32(); 1084| 47| EmitBr(depth, drop_count, keep_count, catch_drop_count); 1085| 47| istream_.ResolveFixupU32(fixup); 1086| 47| return Result::Ok; 1087| 47|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13OnBrTableExprEjPjj: 1091| 1.35k| Index default_target_depth) { 1092| 1.35k| CHECK_RESULT(validator_.BeginBrTable(GetLocation())); ------------------ | | 55| 1.35k| do { \ | | 56| 1.35k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 1.35k] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 1.35k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1093| 1.35k| Index drop_count, keep_count, catch_drop_count; 1094| 1.35k| istream_.Emit(Opcode::BrTable, num_targets); 1095| | 1096| 3.50k| for (Index i = 0; i < num_targets; ++i) { ------------------ | Branch (1096:21): [True: 2.16k, False: 1.34k] ------------------ 1097| 2.16k| Index depth = target_depths[i]; 1098| 2.16k| CHECK_RESULT( ------------------ | | 55| 2.16k| do { \ | | 56| 2.16k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 11, False: 2.15k] | | ------------------ | | 57| 11| return ::wabt::Result::Error; \ | | 58| 11| } \ | | 59| 2.16k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1099| 2.16k| validator_.OnBrTableTarget(GetLocation(), Var(depth, GetLocation()))); 1100| 2.15k| CHECK_RESULT(GetBrDropKeepCount(depth, &drop_count, &keep_count)); ------------------ | | 55| 2.15k| do { \ | | 56| 2.15k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2.15k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2.15k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1101| 2.15k| CHECK_RESULT(validator_.GetCatchCount(depth, &catch_drop_count)); ------------------ | | 55| 2.15k| do { \ | | 56| 2.15k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2.15k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2.15k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1102| | // Emit DropKeep directly (instead of using EmitDropKeep) so the 1103| | // instruction has a fixed size. Same for CatchDrop as well. 1104| 2.15k| istream_.Emit(Opcode::InterpDropKeep, drop_count, keep_count); 1105| 2.15k| istream_.Emit(Opcode::InterpCatchDrop, catch_drop_count); 1106| 2.15k| EmitBr(depth, 0, 0, 0); 1107| 2.15k| } 1108| 1.34k| CHECK_RESULT(validator_.OnBrTableTarget( ------------------ | | 55| 1.34k| do { \ | | 56| 1.34k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 1.34k] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 1.34k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1109| 1.34k| GetLocation(), Var(default_target_depth, GetLocation()))); 1110| 1.34k| CHECK_RESULT( ------------------ | | 55| 1.34k| do { \ | | 56| 1.34k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.34k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.34k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1111| 1.34k| GetBrDropKeepCount(default_target_depth, &drop_count, &keep_count)); 1112| 1.34k| CHECK_RESULT( ------------------ | | 55| 1.34k| do { \ | | 56| 1.34k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.34k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.34k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1113| 1.34k| validator_.GetCatchCount(default_target_depth, &catch_drop_count)); 1114| | // The default case doesn't need a fixed size, since it is never jumped over. 1115| 1.34k| istream_.EmitDropKeep(drop_count, keep_count); 1116| 1.34k| istream_.Emit(Opcode::InterpCatchDrop, catch_drop_count); 1117| 1.34k| EmitBr(default_target_depth, 0, 0, 0); 1118| | 1119| 1.34k| CHECK_RESULT(validator_.EndBrTable(GetLocation())); ------------------ | | 55| 1.34k| do { \ | | 56| 1.34k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.34k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.34k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1120| 1.34k| return Result::Ok; 1121| 1.34k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp10OnCallExprEj: 1123| 643|Result BinaryReaderInterp::OnCallExpr(Index func_index) { 1124| 643| CHECK_RESULT( ------------------ | | 55| 643| do { \ | | 56| 643| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 3, False: 640] | | ------------------ | | 57| 3| return ::wabt::Result::Error; \ | | 58| 3| } \ | | 59| 643| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1125| 643| validator_.OnCall(GetLocation(), Var(func_index, GetLocation()))); 1126| | 1127| 640| if (func_index >= num_func_imports()) { ------------------ | Branch (1127:7): [True: 640, False: 0] ------------------ 1128| 640| istream_.Emit(Opcode::Call, func_index); 1129| 640| } else { 1130| 0| istream_.Emit(Opcode::InterpCallImport, func_index); 1131| 0| } 1132| | 1133| 640| return Result::Ok; 1134| 643|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp18OnCallIndirectExprEjj: 1137| 338| Index table_index) { 1138| 338| CHECK_RESULT(validator_.OnCallIndirect(GetLocation(), ------------------ | | 55| 338| do { \ | | 56| 338| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 336] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 338| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1139| 338| Var(sig_index, GetLocation()), 1140| 338| Var(table_index, GetLocation()))); 1141| 336| istream_.Emit(Opcode::CallIndirect, table_index, sig_index); 1142| 336| return Result::Ok; 1143| 338|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11OnCatchExprEj: 1534| 4|Result BinaryReaderInterp::OnCatchExpr(Index tag_index) { 1535| 4| CHECK_RESULT( ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 4, False: 0] | | ------------------ | | 57| 4| return ::wabt::Result::Error; \ | | 58| 4| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1536| 4| validator_.OnCatch(GetLocation(), Var(tag_index, GetLocation()), false)); 1537| 0| Label* label = TopLabel(); 1538| 0| HandlerDesc& desc = func_->handlers[label->handler_desc_index]; 1539| 0| desc.kind = HandlerKind::Catch; 1540| | // Drop the previous block's exception if it was a catch. 1541| 0| if (label->kind == LabelKind::Block) { ------------------ | Branch (1541:7): [True: 0, False: 0] ------------------ 1542| 0| istream_.EmitCatchDrop(1); 1543| 0| } 1544| | // Jump to the end of the block at the end of the previous try or catch. 1545| 0| Istream::Offset offset = label->offset; 1546| 0| istream_.Emit(Opcode::Br); 1547| 0| assert(offset == Istream::kInvalidOffset); 1548| 0| depth_fixups_.Append(label_stack_.size() - 1, istream_.end()); 1549| 0| istream_.Emit(offset); 1550| | // The offset is only set after the first catch block, as the offset range 1551| | // should only cover the try block itself. 1552| 0| if (desc.try_end_offset == Istream::kInvalidOffset) { ------------------ | Branch (1552:7): [True: 0, False: 0] ------------------ 1553| 0| desc.try_end_offset = istream_.end(); 1554| 0| } 1555| | // The label kind is switched to Block from Try in order to distinguish 1556| | // catch blocks from try blocks. This is used to ensure that a try-delegate 1557| | // inside this catch will not delegate to the catch, and instead find outer 1558| | // try blocks to use as a delegate target. 1559| 0| label->kind = LabelKind::Block; 1560| 0| desc.catches.push_back(CatchDesc{tag_index, istream_.end()}); 1561| 0| return Result::Ok; 1562| 0|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp8TopLabelEv: 397| 404|Label* BinaryReaderInterp::TopLabel() { 398| 404| return GetLabel(0); 399| 404|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13OnCompareExprENS_6OpcodeE: 1202| 12.0k|Result BinaryReaderInterp::OnCompareExpr(Opcode opcode) { 1203| 12.0k| CHECK_RESULT(validator_.OnCompare(GetLocation(), opcode)); ------------------ | | 55| 12.0k| do { \ | | 56| 12.0k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 26, False: 12.0k] | | ------------------ | | 57| 26| return ::wabt::Result::Error; \ | | 58| 26| } \ | | 59| 12.0k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1204| 12.0k| istream_.Emit(opcode); 1205| 12.0k| return Result::Ok; 1206| 12.0k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13OnConvertExprENS_6OpcodeE: 1208| 19.8k|Result BinaryReaderInterp::OnConvertExpr(Opcode opcode) { 1209| 19.8k| CHECK_RESULT(validator_.OnConvert(GetLocation(), opcode)); ------------------ | | 55| 19.8k| do { \ | | 56| 19.8k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 6, False: 19.8k] | | ------------------ | | 57| 6| return ::wabt::Result::Error; \ | | 58| 6| } \ | | 59| 19.8k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1210| 19.8k| istream_.Emit(opcode); 1211| 19.8k| return Result::Ok; 1212| 19.8k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp10OnDropExprEv: 1214| 94|Result BinaryReaderInterp::OnDropExpr() { 1215| 94| CHECK_RESULT(validator_.OnDrop(GetLocation())); ------------------ | | 55| 94| do { \ | | 56| 94| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 94] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 94| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1216| 94| istream_.Emit(Opcode::Drop); 1217| 94| return Result::Ok; 1218| 94|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp10OnElseExprEv: 1032| 183|Result BinaryReaderInterp::OnElseExpr() { 1033| 183| CHECK_RESULT(validator_.OnElse(GetLocation())); ------------------ | | 55| 183| do { \ | | 56| 183| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 183] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 183| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1034| 183| Label* label = TopLabel(); 1035| 183| Istream::Offset fixup_cond_offset = label->fixup_offset; 1036| 183| istream_.Emit(Opcode::Br); 1037| 183| label->fixup_offset = istream_.EmitFixupU32(); 1038| 183| istream_.ResolveFixupU32(fixup_cond_offset); 1039| 183| return Result::Ok; 1040| 183|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp9OnEndExprEv: 1042| 2.91k|Result BinaryReaderInterp::OnEndExpr() { 1043| 2.91k| if (label_stack_.size() == 1) { ------------------ | Branch (1043:7): [True: 2.14k, False: 776] ------------------ 1044| 2.14k| return Result::Ok; 1045| 2.14k| } 1046| 776| SharedValidator::Label* label; 1047| 776| CHECK_RESULT(validator_.GetLabel(0, &label)); ------------------ | | 55| 776| do { \ | | 56| 776| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 776] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 776| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1048| 776| LabelType label_type = label->label_type; 1049| 776| CHECK_RESULT(validator_.OnEnd(GetLocation())); ------------------ | | 55| 776| do { \ | | 56| 776| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 3, False: 773] | | ------------------ | | 57| 3| return ::wabt::Result::Error; \ | | 58| 3| } \ | | 59| 776| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1050| 773| if (label_type == LabelType::If || label_type == LabelType::Else) { ------------------ | Branch (1050:7): [True: 94, False: 679] | Branch (1050:38): [True: 127, False: 552] ------------------ 1051| 221| istream_.ResolveFixupU32(TopLabel()->fixup_offset); 1052| 552| } else if (label_type == LabelType::Try) { ------------------ | Branch (1052:14): [True: 0, False: 552] ------------------ 1053| | // Catch-less try blocks need to fill in the handler description 1054| | // so that it can trigger an exception rethrow when it's reached. 1055| 0| Label* local_label = TopLabel(); 1056| 0| HandlerDesc& desc = func_->handlers[local_label->handler_desc_index]; 1057| 0| desc.try_end_offset = istream_.end(); 1058| 0| assert(desc.catches.size() == 0); 1059| 552| } else if (label_type == LabelType::Catch) { ------------------ | Branch (1059:14): [True: 0, False: 552] ------------------ 1060| 0| istream_.EmitCatchDrop(1); 1061| 0| } 1062| 773| FixupTopLabel(); 1063| 773| PopLabel(); 1064| 773| return Result::Ok; 1065| 773|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnF32ConstExprEj: 1232| 2.11k|Result BinaryReaderInterp::OnF32ConstExpr(uint32_t value_bits) { 1233| 2.11k| CHECK_RESULT(validator_.OnConst(GetLocation(), Type::F32)); ------------------ | | 55| 2.11k| do { \ | | 56| 2.11k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2.11k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2.11k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1234| 2.11k| istream_.Emit(Opcode::F32Const, value_bits); 1235| 2.11k| return Result::Ok; 1236| 2.11k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnF64ConstExprEm: 1238| 136|Result BinaryReaderInterp::OnF64ConstExpr(uint64_t value_bits) { 1239| 136| CHECK_RESULT(validator_.OnConst(GetLocation(), Type::F64)); ------------------ | | 55| 136| do { \ | | 56| 136| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 136] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 136| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1240| 136| istream_.Emit(Opcode::F64Const, value_bits); 1241| 136| return Result::Ok; 1242| 136|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp15OnV128ConstExprE4v128: 1244| 22|Result BinaryReaderInterp::OnV128ConstExpr(v128 value_bits) { 1245| 22| CHECK_RESULT(validator_.OnConst(GetLocation(), Type::V128)); ------------------ | | 55| 22| do { \ | | 56| 22| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 22] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 22| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1246| 22| istream_.Emit(Opcode::V128Const, value_bits); 1247| 22| return Result::Ok; 1248| 22|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp15OnGlobalGetExprEj: 1250| 197|Result BinaryReaderInterp::OnGlobalGetExpr(Index global_index) { 1251| 197| CHECK_RESULT( ------------------ | | 55| 197| do { \ | | 56| 197| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 3, False: 194] | | ------------------ | | 57| 3| return ::wabt::Result::Error; \ | | 58| 3| } \ | | 59| 197| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1252| 197| validator_.OnGlobalGet(GetLocation(), Var(global_index, GetLocation()))); 1253| 194| istream_.Emit(Opcode::GlobalGet, global_index); 1254| 194| return Result::Ok; 1255| 197|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp15OnGlobalSetExprEj: 1257| 33|Result BinaryReaderInterp::OnGlobalSetExpr(Index global_index) { 1258| 33| CHECK_RESULT( ------------------ | | 55| 33| do { \ | | 56| 33| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 3, False: 30] | | ------------------ | | 57| 3| return ::wabt::Result::Error; \ | | 58| 3| } \ | | 59| 33| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1259| 33| validator_.OnGlobalSet(GetLocation(), Var(global_index, GetLocation()))); 1260| 30| istream_.Emit(Opcode::GlobalSet, global_index); 1261| 30| return Result::Ok; 1262| 33|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnI32ConstExprEj: 1220| 23.8k|Result BinaryReaderInterp::OnI32ConstExpr(uint32_t value) { 1221| 23.8k| CHECK_RESULT(validator_.OnConst(GetLocation(), Type::I32)); ------------------ | | 55| 23.8k| do { \ | | 56| 23.8k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 23.8k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 23.8k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1222| 23.8k| istream_.Emit(Opcode::I32Const, value); 1223| 23.8k| return Result::Ok; 1224| 23.8k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnI64ConstExprEm: 1226| 574|Result BinaryReaderInterp::OnI64ConstExpr(uint64_t value) { 1227| 574| CHECK_RESULT(validator_.OnConst(GetLocation(), Type::I64)); ------------------ | | 55| 574| do { \ | | 56| 574| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 574] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 574| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1228| 574| istream_.Emit(Opcode::I64Const, value); 1229| 574| return Result::Ok; 1230| 574|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp8OnIfExprENS_4TypeE: 1024| 552|Result BinaryReaderInterp::OnIfExpr(Type sig_type) { 1025| 552| CHECK_RESULT(validator_.OnIf(GetLocation(), sig_type)); ------------------ | | 55| 552| do { \ | | 56| 552| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5, False: 547] | | ------------------ | | 57| 5| return ::wabt::Result::Error; \ | | 58| 5| } \ | | 59| 552| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1026| 547| istream_.Emit(Opcode::InterpBrUnless); 1027| 547| auto fixup = istream_.EmitFixupU32(); 1028| 547| PushLabel(LabelKind::Block, Istream::kInvalidOffset, fixup); 1029| 547| return Result::Ok; 1030| 552|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp10OnLoadExprENS_6OpcodeEjmm: 1299| 4.18k| Address offset) { 1300| 4.18k| CHECK_RESULT(validator_.OnLoad(GetLocation(), opcode, ------------------ | | 55| 4.18k| do { \ | | 56| 4.18k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 29, False: 4.15k] | | ------------------ | | 57| 29| return ::wabt::Result::Error; \ | | 58| 29| } \ | | 59| 4.18k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1301| 4.18k| Var(memidx, GetLocation()), 1302| 4.18k| GetAlignment(align_log2), offset)); 1303| 4.15k| istream_.Emit(opcode, memidx, offset); 1304| 4.15k| return Result::Ok; 1305| 4.18k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnLocalGetExprEj: 1269| 1.94k|Result BinaryReaderInterp::OnLocalGetExpr(Index local_index) { 1270| | // Get the translated index before calling validator_.OnLocalGet because it 1271| | // will update the type stack size. We need the index to be relative to the 1272| | // old stack size. 1273| 1.94k| Index translated_local_index = TranslateLocalIndex(local_index); 1274| 1.94k| CHECK_RESULT( ------------------ | | 55| 1.94k| do { \ | | 56| 1.94k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 7, False: 1.93k] | | ------------------ | | 57| 7| return ::wabt::Result::Error; \ | | 58| 7| } \ | | 59| 1.94k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1275| 1.94k| validator_.OnLocalGet(GetLocation(), Var(local_index, GetLocation()))); 1276| 1.93k| istream_.Emit(Opcode::LocalGet, translated_local_index); 1277| 1.93k| return Result::Ok; 1278| 1.94k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp19TranslateLocalIndexEj: 1264| 2.71k|Index BinaryReaderInterp::TranslateLocalIndex(Index local_index) { 1265| 2.71k| return validator_.type_stack_size() + validator_.GetLocalCount() - 1266| 2.71k| local_index; 1267| 2.71k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnLocalSetExprEj: 1280| 729|Result BinaryReaderInterp::OnLocalSetExpr(Index local_index) { 1281| | // See comment in OnLocalGetExpr above. 1282| 729| Index translated_local_index = TranslateLocalIndex(local_index); 1283| 729| CHECK_RESULT( ------------------ | | 55| 729| do { \ | | 56| 729| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 727] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 729| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1284| 729| validator_.OnLocalSet(GetLocation(), Var(local_index, GetLocation()))); 1285| 727| istream_.Emit(Opcode::LocalSet, translated_local_index); 1286| 727| return Result::Ok; 1287| 729|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnLocalTeeExprEj: 1289| 47|Result BinaryReaderInterp::OnLocalTeeExpr(Index local_index) { 1290| 47| CHECK_RESULT( ------------------ | | 55| 47| do { \ | | 56| 47| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 46] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 47| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1291| 47| validator_.OnLocalTee(GetLocation(), Var(local_index, GetLocation()))); 1292| 46| istream_.Emit(Opcode::LocalTee, TranslateLocalIndex(local_index)); 1293| 46| return Result::Ok; 1294| 47|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp10OnLoopExprENS_4TypeE: 1018| 602|Result BinaryReaderInterp::OnLoopExpr(Type sig_type) { 1019| 602| CHECK_RESULT(validator_.OnLoop(GetLocation(), sig_type)); ------------------ | | 55| 602| do { \ | | 56| 602| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 600] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 602| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1020| 600| PushLabel(LabelKind::Block, istream_.end()); 1021| 600| return Result::Ok; 1022| 602|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnDataDropExprEj: 1438| 1|Result BinaryReaderInterp::OnDataDropExpr(Index segment_index) { 1439| 1| CHECK_RESULT( ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1440| 1| validator_.OnDataDrop(GetLocation(), Var(segment_index, GetLocation()))); 1441| 1| istream_.Emit(Opcode::DataDrop, segment_index); 1442| 1| return Result::Ok; 1443| 1|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp16OnMemoryFillExprEj: 1445| 297|Result BinaryReaderInterp::OnMemoryFillExpr(Index memidx) { 1446| 297| CHECK_RESULT( ------------------ | | 55| 297| do { \ | | 56| 297| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 296] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 297| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1447| 297| validator_.OnMemoryFill(GetLocation(), Var(memidx, GetLocation()))); 1448| 296| istream_.Emit(Opcode::MemoryFill, memidx); 1449| 296| return Result::Ok; 1450| 297|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp16OnMemoryGrowExprEj: 1318| 94|Result BinaryReaderInterp::OnMemoryGrowExpr(Index memidx) { 1319| 94| CHECK_RESULT( ------------------ | | 55| 94| do { \ | | 56| 94| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 92] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 94| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1320| 94| validator_.OnMemoryGrow(GetLocation(), Var(memidx, GetLocation()))); 1321| 92| istream_.Emit(Opcode::MemoryGrow, memidx); 1322| 92| return Result::Ok; 1323| 94|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp16OnMemorySizeExprEj: 1325| 4|Result BinaryReaderInterp::OnMemorySizeExpr(Index memidx) { 1326| 4| CHECK_RESULT( ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1327| 4| validator_.OnMemorySize(GetLocation(), Var(memidx, GetLocation()))); 1328| 4| istream_.Emit(Opcode::MemorySize, memidx); 1329| 4| return Result::Ok; 1330| 4|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp15OnTableCopyExprEjj: 1474| 53|Result BinaryReaderInterp::OnTableCopyExpr(Index dst_index, Index src_index) { 1475| 53| CHECK_RESULT(validator_.OnTableCopy(GetLocation(), ------------------ | | 55| 53| do { \ | | 56| 53| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 52] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 53| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1476| 53| Var(dst_index, GetLocation()), 1477| 53| Var(src_index, GetLocation()))); 1478| 52| istream_.Emit(Opcode::TableCopy, dst_index, src_index); 1479| 52| return Result::Ok; 1480| 53|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnTableGetExprEj: 1460| 50|Result BinaryReaderInterp::OnTableGetExpr(Index table_index) { 1461| 50| CHECK_RESULT( ------------------ | | 55| 50| do { \ | | 56| 50| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 49] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 50| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1462| 50| validator_.OnTableGet(GetLocation(), Var(table_index, GetLocation()))); 1463| 49| istream_.Emit(Opcode::TableGet, table_index); 1464| 49| return Result::Ok; 1465| 50|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnTableSetExprEj: 1467| 94|Result BinaryReaderInterp::OnTableSetExpr(Index table_index) { 1468| 94| CHECK_RESULT( ------------------ | | 55| 94| do { \ | | 56| 94| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 3, False: 91] | | ------------------ | | 57| 3| return ::wabt::Result::Error; \ | | 58| 3| } \ | | 59| 94| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1469| 94| validator_.OnTableSet(GetLocation(), Var(table_index, GetLocation()))); 1470| 91| istream_.Emit(Opcode::TableSet, table_index); 1471| 91| return Result::Ok; 1472| 94|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp15OnTableFillExprEj: 1346| 65|Result BinaryReaderInterp::OnTableFillExpr(Index table_index) { 1347| 65| CHECK_RESULT( ------------------ | | 55| 65| do { \ | | 56| 65| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 65] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 65| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1348| 65| validator_.OnTableFill(GetLocation(), Var(table_index, GetLocation()))); 1349| 65| istream_.Emit(Opcode::TableFill, table_index); 1350| 65| return Result::Ok; 1351| 65|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13OnRefFuncExprEj: 1353| 95|Result BinaryReaderInterp::OnRefFuncExpr(Index func_index) { 1354| 95| CHECK_RESULT( ------------------ | | 55| 95| do { \ | | 56| 95| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 6, False: 89] | | ------------------ | | 57| 6| return ::wabt::Result::Error; \ | | 58| 6| } \ | | 59| 95| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1355| 95| validator_.OnRefFunc(GetLocation(), Var(func_index, GetLocation()))); 1356| 89| istream_.Emit(Opcode::RefFunc, func_index); 1357| 89| return Result::Ok; 1358| 95|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13OnRefNullExprENS_4TypeE: 1360| 27|Result BinaryReaderInterp::OnRefNullExpr(Type type) { 1361| 27| CHECK_RESULT(validator_.OnRefNull(GetLocation(), type)); ------------------ | | 55| 27| do { \ | | 56| 27| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 27] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 27| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1362| 27| istream_.Emit(Opcode::RefNull); 1363| 27| return Result::Ok; 1364| 27|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp15OnRefIsNullExprEv: 1366| 34|Result BinaryReaderInterp::OnRefIsNullExpr() { 1367| 34| CHECK_RESULT(validator_.OnRefIsNull(GetLocation())); ------------------ | | 55| 34| do { \ | | 56| 34| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 34] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 34| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1368| 34| istream_.Emit(Opcode::RefIsNull); 1369| 34| return Result::Ok; 1370| 34|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp9OnNopExprEv: 1372| 32.7k|Result BinaryReaderInterp::OnNopExpr() { 1373| 32.7k| CHECK_RESULT(validator_.OnNop(GetLocation())); ------------------ | | 55| 32.7k| do { \ | | 56| 32.7k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 32.7k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 32.7k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1374| 32.7k| return Result::Ok; 1375| 32.7k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13OnRethrowExprEj: 1505| 4|Result BinaryReaderInterp::OnRethrowExpr(Index depth) { 1506| 4| Index catch_depth; 1507| 4| CHECK_RESULT(validator_.OnRethrow(GetLocation(), Var(depth, GetLocation()))); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 4, False: 0] | | ------------------ | | 57| 4| return ::wabt::Result::Error; \ | | 58| 4| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1508| 0| CHECK_RESULT(validator_.GetCatchCount(depth, &catch_depth)); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1509| | // The rethrow opcode takes an index into the exception stack rather than 1510| | // the number of catch nestings, so we subtract one here. 1511| 0| istream_.Emit(Opcode::Rethrow, catch_depth - 1); 1512| 0| return Result::Ok; 1513| 0|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp12OnReturnExprEv: 1377| 1.72k|Result BinaryReaderInterp::OnReturnExpr() { 1378| 1.72k| Index drop_count, keep_count, catch_drop_count; 1379| 1.72k| CHECK_RESULT(GetReturnDropKeepCount(&drop_count, &keep_count)); ------------------ | | 55| 1.72k| do { \ | | 56| 1.72k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.72k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.72k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1380| 1.72k| CHECK_RESULT( ------------------ | | 55| 1.72k| do { \ | | 56| 1.72k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.72k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.72k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1381| 1.72k| validator_.GetCatchCount(label_stack_.size() - 1, &catch_drop_count)); 1382| 1.72k| CHECK_RESULT(validator_.OnReturn(GetLocation())); ------------------ | | 55| 1.72k| do { \ | | 56| 1.72k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.72k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.72k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1383| 1.72k| istream_.EmitDropKeep(drop_count, keep_count); 1384| 1.72k| istream_.EmitCatchDrop(catch_drop_count); 1385| 1.72k| istream_.Emit(Opcode::Return); 1386| 1.72k| return Result::Ok; 1387| 1.72k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp22GetReturnDropKeepCountEPjS3_: 433| 3.58k| Index* out_keep_count) { 434| 3.58k| CHECK_RESULT(GetBrDropKeepCount(label_stack_.size() - 1, out_drop_count, ------------------ | | 55| 3.58k| do { \ | | 56| 3.58k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 3.58k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 3.58k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 435| 3.58k| out_keep_count)); 436| 3.58k| *out_drop_count += validator_.GetLocalCount(); 437| 3.58k| return Result::Ok; 438| 3.58k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp16OnReturnCallExprEj: 1145| 2|Result BinaryReaderInterp::OnReturnCallExpr(Index func_index) { 1146| 2| CHECK_RESULT( ------------------ | | 55| 2| do { \ | | 56| 2| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1147| 2| validator_.OnReturnCall(GetLocation(), Var(func_index, GetLocation()))); 1148| | 1149| 2| FuncType& func_type = func_types_[func_index]; 1150| | 1151| 2| Index drop_count, keep_count, catch_drop_count; 1152| 2| CHECK_RESULT( ------------------ | | 55| 2| do { \ | | 56| 2| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1153| 2| GetReturnCallDropKeepCount(func_type, 0, &drop_count, &keep_count)); 1154| 2| CHECK_RESULT( ------------------ | | 55| 2| do { \ | | 56| 2| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1155| 2| validator_.GetCatchCount(label_stack_.size() - 1, &catch_drop_count)); 1156| | // The validator must be run after we get the drop/keep counts, since it 1157| | // will change the type stack. 1158| 2| CHECK_RESULT( ------------------ | | 55| 2| do { \ | | 56| 2| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 2] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 2| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1159| 2| validator_.OnReturnCall(GetLocation(), Var(func_index, GetLocation()))); 1160| 2| istream_.EmitDropKeep(drop_count, keep_count); 1161| 2| istream_.EmitCatchDrop(catch_drop_count); 1162| | 1163| 2| if (func_index >= num_func_imports()) { ------------------ | Branch (1163:7): [True: 2, False: 0] ------------------ 1164| 2| istream_.Emit(Opcode::InterpAdjustFrameForReturnCall, func_index); 1165| 2| istream_.Emit(Opcode::Br); 1166| | // We emit this separately to ensure that the fixup generated by 1167| | // GetFuncOffset comes after the Br opcode. 1168| 2| istream_.Emit(GetFuncOffset(func_index)); 1169| 2| } else { 1170| 0| istream_.Emit(Opcode::InterpCallImport, func_index); 1171| 0| istream_.Emit(Opcode::Return); 1172| 0| } 1173| | 1174| 2| return Result::Ok; 1175| 2|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp26GetReturnCallDropKeepCountERKNS0_8FuncTypeEjPjS6_: 443| 110| Index* out_keep_count) { 444| 110| Index keep_count = static_cast(func_type.params.size()) + keep_extra; 445| 110| CHECK_RESULT(GetDropCount(keep_count, 0, out_drop_count)); ------------------ | | 55| 110| do { \ | | 56| 110| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 110] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 110| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 446| 110| *out_drop_count += validator_.GetLocalCount(); 447| 110| *out_keep_count = keep_count; 448| 110| return Result::Ok; 449| 110|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13GetFuncOffsetEj: 471| 2|u32 BinaryReaderInterp::GetFuncOffset(Index func_index) { 472| 2| assert(func_index >= num_func_imports()); 473| 2| FuncDesc& func = module_.funcs[func_index - num_func_imports()]; 474| 2| if (func.code_offset == Istream::kInvalidOffset) { ------------------ | Branch (474:7): [True: 0, False: 2] ------------------ 475| 0| func_fixups_.Append(func_index, istream_.end()); 476| 0| } 477| 2| return func.code_offset; 478| 2|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp24OnReturnCallIndirectExprEjj: 1178| 114| Index table_index) { 1179| 114| CHECK_RESULT(validator_.OnReturnCallIndirect( ------------------ | | 55| 114| do { \ | | 56| 114| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 6, False: 108] | | ------------------ | | 57| 6| return ::wabt::Result::Error; \ | | 58| 6| } \ | | 59| 114| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1180| 114| GetLocation(), Var(sig_index, GetLocation()), 1181| 114| Var(table_index, GetLocation()))); 1182| | 1183| 108| FuncType& func_type = module_.func_types[sig_index]; 1184| | 1185| 108| Index drop_count, keep_count, catch_drop_count; 1186| | // +1 to include the index of the function. 1187| 108| CHECK_RESULT( ------------------ | | 55| 108| do { \ | | 56| 108| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 108] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 108| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1188| 108| GetReturnCallDropKeepCount(func_type, +1, &drop_count, &keep_count)); 1189| 108| CHECK_RESULT( ------------------ | | 55| 108| do { \ | | 56| 108| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 108] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 108| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1190| 108| validator_.GetCatchCount(label_stack_.size() - 1, &catch_drop_count)); 1191| | // The validator must be run after we get the drop/keep counts, since it 1192| | // changes the type stack. 1193| 108| CHECK_RESULT(validator_.OnReturnCallIndirect( ------------------ | | 55| 108| do { \ | | 56| 108| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 108] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 108| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1194| 108| GetLocation(), Var(sig_index, GetLocation()), 1195| 108| Var(table_index, GetLocation()))); 1196| 108| istream_.EmitDropKeep(drop_count, keep_count); 1197| 108| istream_.EmitCatchDrop(catch_drop_count); 1198| 108| istream_.Emit(Opcode::ReturnCallIndirect, table_index, sig_index); 1199| 108| return Result::Ok; 1200| 108|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp12OnSelectExprEjPNS_4TypeE: 1390| 966| Type* result_types) { 1391| 966| CHECK_RESULT(validator_.OnSelect(GetLocation(), result_count, result_types)); ------------------ | | 55| 966| do { \ | | 56| 966| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 964] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 966| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1392| 964| istream_.Emit(Opcode::Select); 1393| 964| return Result::Ok; 1394| 966|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11OnStoreExprENS_6OpcodeEjmm: 1310| 333| Address offset) { 1311| 333| CHECK_RESULT(validator_.OnStore(GetLocation(), opcode, ------------------ | | 55| 333| do { \ | | 56| 333| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 4, False: 329] | | ------------------ | | 57| 4| return ::wabt::Result::Error; \ | | 58| 4| } \ | | 59| 333| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1312| 333| Var(memidx, GetLocation()), 1313| 333| GetAlignment(align_log2), offset)); 1314| 329| istream_.Emit(opcode, memidx, offset); 1315| 329| return Result::Ok; 1316| 333|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11OnThrowExprEj: 1498| 1|Result BinaryReaderInterp::OnThrowExpr(Index tag_index) { 1499| 1| CHECK_RESULT( ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 0] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1500| 1| validator_.OnThrow(GetLocation(), Var(tag_index, GetLocation()))); 1501| 0| istream_.Emit(Opcode::Throw, tag_index); 1502| 0| return Result::Ok; 1503| 1|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp9OnTryExprENS_4TypeE: 1515| 1|Result BinaryReaderInterp::OnTryExpr(Type sig_type) { 1516| 1| u32 exn_stack_height; 1517| 1| CHECK_RESULT( ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1518| 1| validator_.GetCatchCount(label_stack_.size() - 1, &exn_stack_height)); 1519| 1| u32 value_stack_height = validator_.type_stack_size(); 1520| 1| CHECK_RESULT(validator_.OnTry(GetLocation(), sig_type)); ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 0] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1521| | // Push a label that tracks mapping of exn -> catch 1522| 0| PushLabel(LabelKind::Try, Istream::kInvalidOffset, Istream::kInvalidOffset, 1523| 0| func_->handlers.size()); 1524| 0| func_->handlers.push_back(HandlerDesc{HandlerKind::Catch, 1525| 0| istream_.end(), 1526| 0| Istream::kInvalidOffset, 1527| 0| {}, 1528| 0| {Istream::kInvalidOffset}, 1529| 0| value_stack_height, 1530| 0| exn_stack_height}); 1531| 0| return Result::Ok; 1532| 1|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11OnUnaryExprENS_6OpcodeE: 888| 33.4k|Result BinaryReaderInterp::OnUnaryExpr(Opcode opcode) { 889| 33.4k| CHECK_RESULT(validator_.OnUnary(GetLocation(), opcode)); ------------------ | | 55| 33.4k| do { \ | | 56| 33.4k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 19, False: 33.4k] | | ------------------ | | 57| 19| return ::wabt::Result::Error; \ | | 58| 19| } \ | | 59| 33.4k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 890| 33.4k| istream_.Emit(opcode); 891| 33.4k| return Result::Ok; 892| 33.4k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp17OnUnreachableExprEv: 1396| 188k|Result BinaryReaderInterp::OnUnreachableExpr() { 1397| 188k| CHECK_RESULT(validator_.OnUnreachable(GetLocation())); ------------------ | | 55| 188k| do { \ | | 56| 188k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 2, False: 188k] | | ------------------ | | 57| 2| return ::wabt::Result::Error; \ | | 58| 2| } \ | | 59| 188k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1398| 188k| istream_.Emit(Opcode::Unreachable); 1399| 188k| return Result::Ok; 1400| 188k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp15EndFunctionBodyEj: 844| 1.85k|Result BinaryReaderInterp::EndFunctionBody(Index index) { 845| 1.85k| FixupTopLabel(); 846| 1.85k| Index drop_count, keep_count; 847| 1.85k| CHECK_RESULT(GetReturnDropKeepCount(&drop_count, &keep_count)); ------------------ | | 55| 1.85k| do { \ | | 56| 1.85k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.85k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.85k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 848| 1.85k| CHECK_RESULT(validator_.EndFunctionBody(GetLocation())); ------------------ | | 55| 1.85k| do { \ | | 56| 1.85k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5, False: 1.85k] | | ------------------ | | 57| 5| return ::wabt::Result::Error; \ | | 58| 5| } \ | | 59| 1.85k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 849| 1.85k| istream_.EmitDropKeep(drop_count, keep_count); 850| 1.85k| istream_.Emit(Opcode::Return); 851| 1.85k| PopLabel(); 852| 1.85k| func_ = nullptr; 853| 1.85k| return Result::Ok; 854| 1.85k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp16OnSimdLaneOpExprENS_6OpcodeEm: 900| 1.02k|Result BinaryReaderInterp::OnSimdLaneOpExpr(Opcode opcode, uint64_t value) { 901| 1.02k| CHECK_RESULT(validator_.OnSimdLaneOp(GetLocation(), opcode, value)); ------------------ | | 55| 1.02k| do { \ | | 56| 1.02k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 3, False: 1.02k] | | ------------------ | | 57| 3| return ::wabt::Result::Error; \ | | 58| 3| } \ | | 59| 1.02k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 902| 1.02k| istream_.Emit(opcode, static_cast(value)); 903| 1.02k| return Result::Ok; 904| 1.02k|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp19OnSimdShuffleOpExprENS_6OpcodeE4v128: 934| 4|Result BinaryReaderInterp::OnSimdShuffleOpExpr(Opcode opcode, v128 value) { 935| 4| CHECK_RESULT(validator_.OnSimdShuffleOp(GetLocation(), opcode, value)); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 4, False: 0] | | ------------------ | | 57| 4| return ::wabt::Result::Error; \ | | 58| 4| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 936| 0| istream_.Emit(opcode, value); 937| 0| return Result::Ok; 938| 4|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp18OnSimdLoadLaneExprENS_6OpcodeEjmmm: 914| 169| uint64_t value) { 915| 169| CHECK_RESULT(validator_.OnSimdLoadLane( ------------------ | | 55| 169| do { \ | | 56| 169| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 168] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 169| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 916| 169| GetLocation(), opcode, Var(memidx, GetLocation()), 917| 169| GetAlignment(alignment_log2), offset, value)); 918| 168| istream_.Emit(opcode, memidx, offset, static_cast(value)); 919| 168| return Result::Ok; 920| 169|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp19OnSimdStoreLaneExprENS_6OpcodeEjmmm: 926| 201| uint64_t value) { 927| 201| CHECK_RESULT(validator_.OnSimdStoreLane( ------------------ | | 55| 201| do { \ | | 56| 201| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 8, False: 193] | | ------------------ | | 57| 8| return ::wabt::Result::Error; \ | | 58| 8| } \ | | 59| 201| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 928| 201| GetLocation(), opcode, Var(memidx, GetLocation()), 929| 201| GetAlignment(alignment_log2), offset, value)); 930| 193| istream_.Emit(opcode, memidx, offset, static_cast(value)); 931| 193| return Result::Ok; 932| 201|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp15OnLoadSplatExprENS_6OpcodeEjmm: 943| 396| Address offset) { 944| 396| CHECK_RESULT(validator_.OnLoadSplat(GetLocation(), opcode, ------------------ | | 55| 396| do { \ | | 56| 396| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 396] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 396| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 945| 396| Var(memidx, GetLocation()), 946| 396| GetAlignment(align_log2), offset)); 947| 396| istream_.Emit(opcode, memidx, offset); 948| 396| return Result::Ok; 949| 396|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp14OnLoadZeroExprENS_6OpcodeEjmm: 954| 444| Address offset) { 955| 444| CHECK_RESULT(validator_.OnLoadZero(GetLocation(), opcode, ------------------ | | 55| 444| do { \ | | 56| 444| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 444] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 444| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 956| 444| Var(memidx, GetLocation()), 957| 444| GetAlignment(align_log2), offset)); 958| 444| istream_.Emit(opcode, memidx, offset); 959| 444| return Result::Ok; 960| 444|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp18OnElemSegmentCountEj: 701| 33|Result BinaryReaderInterp::OnElemSegmentCount(Index count) { 702| 33| module_.elems.reserve(count); 703| 33| return Result::Ok; 704| 33|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp16BeginElemSegmentEjjh: 708| 22| uint8_t flags) { 709| 22| auto mode = ToSegmentMode(flags); 710| 22| CHECK_RESULT(validator_.OnElemSegment(GetLocation(), ------------------ | | 55| 22| do { \ | | 56| 22| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5, False: 17] | | ------------------ | | 57| 5| return ::wabt::Result::Error; \ | | 58| 5| } \ | | 59| 22| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 711| 22| Var(table_index, GetLocation()), mode)); 712| | 713| 17| ValueType offset_type = ValueType::I32; 714| 17| if (table_index < table_types_.size() && ------------------ | Branch (714:7): [True: 15, False: 2] ------------------ 715| 17| table_types_[table_index].limits.is_64) { ------------------ | Branch (715:7): [True: 0, False: 15] ------------------ 716| 0| offset_type = ValueType::I64; 717| 0| } 718| 17| FuncDesc init_func{ 719| 17| FuncType{{}, {offset_type}}, {}, Istream::kInvalidOffset, {}}; 720| 17| ElemDesc desc{{}, ValueType::Void, mode, table_index, init_func}; 721| 17| module_.elems.push_back(desc); 722| 17| return Result::Ok; 723| 22|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_113ToSegmentModeEh: 41| 44|SegmentMode ToSegmentMode(uint8_t flags) { 42| 44| if ((flags & SegDeclared) == SegDeclared) { ------------------ | Branch (42:7): [True: 12, False: 32] ------------------ 43| 12| return SegmentMode::Declared; 44| 32| } else if ((flags & SegPassive) == SegPassive) { ------------------ | Branch (44:14): [True: 6, False: 26] ------------------ 45| 6| return SegmentMode::Passive; 46| 26| } else { 47| 26| return SegmentMode::Active; 48| 26| } 49| 44|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp24BeginElemSegmentInitExprEj: 725| 15|Result BinaryReaderInterp::BeginElemSegmentInitExpr(Index index) { 726| 15| ElemDesc& elem = module_.elems.back(); 727| 15| return BeginInitExpr(&elem.init_func); 728| 15|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp22EndElemSegmentInitExprEj: 730| 15|Result BinaryReaderInterp::EndElemSegmentInitExpr(Index index) { 731| 15| return EndInitExpr(); 732| 15|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp21OnElemSegmentElemTypeEjNS_4TypeE: 734| 17|Result BinaryReaderInterp::OnElemSegmentElemType(Index index, Type elem_type) { 735| 17| ElemDesc& elem = module_.elems.back(); 736| 17| elem.type = elem_type; 737| 17| return validator_.OnElemSegmentElemType(GetLocation(), elem_type); 738| 17|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp26OnElemSegmentElemExprCountEjj: 741| 16| Index count) { 742| 16| ElemDesc& elem = module_.elems.back(); 743| 16| elem.elements.reserve(count); 744| 16| return Result::Ok; 745| 16|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp13BeginElemExprEjj: 747| 82|Result BinaryReaderInterp::BeginElemExpr(Index elem_index, Index expr_index) { 748| 82| assert(elem_index == module_.elems.size() - 1); 749| 82| ElemDesc& elem = module_.elems.back(); 750| 82| elem.elements.push_back( 751| 82| {FuncType{{}, {elem.type}}, {}, Istream::kInvalidOffset, {}}); 752| 82| assert(expr_index == elem.elements.size() - 1); 753| 82| return BeginInitExpr(&elem.elements.back()); 754| 82|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11EndElemExprEjj: 756| 77|Result BinaryReaderInterp::EndElemExpr(Index elem_index, Index expr_index) { 757| 77| return EndInitExpr(); 758| 77|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp16BeginDataSegmentEjjh: 777| 22| uint8_t flags) { 778| 22| auto mode = ToSegmentMode(flags); 779| 22| CHECK_RESULT(validator_.OnDataSegment( ------------------ | | 55| 22| do { \ | | 56| 22| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 5, False: 17] | | ------------------ | | 57| 5| return ::wabt::Result::Error; \ | | 58| 5| } \ | | 59| 22| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 780| 22| GetLocation(), Var(memory_index, GetLocation()), mode)); 781| | 782| 17| ValueType offset_type = ValueType::I32; 783| 17| if (memory_index < memory_types_.size() && ------------------ | Branch (783:7): [True: 2, False: 15] ------------------ 784| 17| memory_types_[memory_index].limits.is_64) { ------------------ | Branch (784:7): [True: 0, False: 2] ------------------ 785| 0| offset_type = ValueType::I64; 786| 0| } 787| 17| FuncDesc init_func{ 788| 17| FuncType{{}, {offset_type}}, {}, Istream::kInvalidOffset, {}}; 789| 17| DataDesc desc{{}, mode, memory_index, init_func}; 790| 17| module_.datas.push_back(desc); 791| 17| return Result::Ok; 792| 22|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp24BeginDataSegmentInitExprEj: 766| 1|Result BinaryReaderInterp::BeginDataSegmentInitExpr(Index index) { 767| 1| DataDesc& data = module_.datas.back(); 768| 1| return BeginInitExpr(&data.init_func); 769| 1|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp17OnDataSegmentDataEjPKvm: 796| 16| Address size) { 797| 16| DataDesc& dst_data = module_.datas.back(); 798| 16| if (size > 0) { ------------------ | Branch (798:7): [True: 15, False: 1] ------------------ 799| 15| dst_data.data.resize(size); 800| 15| memcpy(dst_data.data.data(), src_data, size); 801| 15| } 802| 16| return Result::Ok; 803| 16|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp11OnDataCountEj: 760| 2|Result BinaryReaderInterp::OnDataCount(Index count) { 761| 2| validator_.OnDataCount(count); 762| 2| module_.datas.reserve(count); 763| 2| return Result::Ok; 764| 2|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp10OnTagCountEj: 660| 8|Result BinaryReaderInterp::OnTagCount(Index count) { 661| 8| module_.tags.reserve(count); 662| 8| return Result::Ok; 663| 8|} binary-reader-interp.cc:_ZN4wabt6interp12_GLOBAL__N_118BinaryReaderInterp9OnTagTypeEjj: 665| 4|Result BinaryReaderInterp::OnTagType(Index index, Index sig_index) { 666| 4| CHECK_RESULT(validator_.OnTag(GetLocation(), Var(sig_index, GetLocation()))); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 4, False: 0] | | ------------------ | | 57| 4| return ::wabt::Result::Error; \ | | 58| 4| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 667| 0| FuncType& func_type = module_.func_types[sig_index]; 668| 0| TagType tag_type{TagAttr::Exception, func_type.params}; 669| 0| module_.tags.push_back(TagDesc{tag_type}); 670| 0| tag_types_.push_back(tag_type); 671| 0| return Result::Ok; 672| 4|} _ZNK4wabt6interp8FuncType5CloneEv: 85| 12.2k|std::unique_ptr FuncType::Clone() const { 86| 12.2k| return std::make_unique(*this); 87| 12.2k|} _ZNK4wabt6interp10MemoryType5CloneEv: 124| 6|std::unique_ptr MemoryType::Clone() const { 125| 6| return std::make_unique(*this); 126| 6|} _ZNK4wabt6interp10GlobalType5CloneEv: 135| 62|std::unique_ptr GlobalType::Clone() const { 136| 62| return std::make_unique(*this); 137| 62|} _ZNK4wabt6interp7TagType5CloneEv: 162| 9|std::unique_ptr TagType::Clone() const { 163| 9| return std::make_unique(*this); 164| 9|} _ZN4wabt6interp7Istream4EmitEj: 38| 4.02k|void Istream::Emit(u32 val) { 39| 4.02k| EmitInternal(val); 40| 4.02k|} _ZN4wabt6interp7Istream4EmitENS_6Opcode4EnumE: 42| 355k|void Istream::Emit(Opcode::Enum op) { 43| 355k| EmitInternal(static_cast(op)); 44| 355k|} _ZN4wabt6interp7Istream4EmitENS_6Opcode4EnumEh: 46| 1.02k|void Istream::Emit(Opcode::Enum op, u8 val) { 47| 1.02k| Emit(op); 48| 1.02k| EmitInternal(val); 49| 1.02k|} _ZN4wabt6interp7Istream4EmitENS_6Opcode4EnumEj: 51| 35.3k|void Istream::Emit(Opcode::Enum op, u32 val) { 52| 35.3k| Emit(op); 53| 35.3k| EmitInternal(val); 54| 35.3k|} _ZN4wabt6interp7Istream4EmitENS_6Opcode4EnumEm: 56| 710|void Istream::Emit(Opcode::Enum op, u64 val) { 57| 710| Emit(op); 58| 710| EmitInternal(val); 59| 710|} _ZN4wabt6interp7Istream4EmitENS_6Opcode4EnumE4v128: 61| 22|void Istream::Emit(Opcode::Enum op, v128 val) { 62| 22| Emit(op); 63| 22| EmitInternal(val); 64| 22|} _ZN4wabt6interp7Istream4EmitENS_6Opcode4EnumEjj: 66| 10.6k|void Istream::Emit(Opcode::Enum op, u32 val1, u32 val2) { 67| 10.6k| Emit(op); 68| 10.6k| EmitInternal(val1); 69| 10.6k| EmitInternal(val2); 70| 10.6k|} _ZN4wabt6interp7Istream4EmitENS_6Opcode4EnumEjjh: 72| 361|void Istream::Emit(Opcode::Enum op, u32 val1, u32 val2, u8 val3) { 73| 361| Emit(op); 74| 361| EmitInternal(val1); 75| 361| EmitInternal(val2); 76| 361| EmitInternal(val3); 77| 361|} _ZN4wabt6interp7Istream12EmitDropKeepEjj: 79| 9.05k|void Istream::EmitDropKeep(u32 drop, u32 keep) { 80| 9.05k| if (drop > 0) { ------------------ | Branch (80:7): [True: 3.06k, False: 5.98k] ------------------ 81| 3.06k| if (drop == 1 && keep == 0) { ------------------ | Branch (81:9): [True: 1.31k, False: 1.75k] | Branch (81:22): [True: 440, False: 875] ------------------ 82| 440| Emit(Opcode::Drop); 83| 2.62k| } else { 84| 2.62k| Emit(Opcode::InterpDropKeep, drop, keep); 85| 2.62k| } 86| 3.06k| } 87| 9.05k|} _ZN4wabt6interp7Istream13EmitCatchDropEj: 89| 5.85k|void Istream::EmitCatchDrop(u32 drop) { 90| 5.85k| if (drop > 0) { ------------------ | Branch (90:7): [True: 0, False: 5.85k] ------------------ 91| 0| Emit(Opcode::InterpCatchDrop, drop); 92| 0| } 93| 5.85k|} _ZN4wabt6interp7Istream12EmitFixupU32Ev: 95| 777|Istream::Offset Istream::EmitFixupU32() { 96| 777| auto result = end(); 97| 777| EmitInternal(kInvalidOffset); 98| 777| return result; 99| 777|} _ZN4wabt6interp7Istream15ResolveFixupU32Ej: 101| 598|void Istream::ResolveFixupU32(Offset fixup_offset) { 102| 598| EmitAt(fixup_offset, end()); 103| 598|} _ZNK4wabt6interp7Istream3endEv: 105| 430k|Istream::Offset Istream::end() const { 106| 430k| return static_cast(data_.size()); 107| 430k|} _ZN4wabt6interp7Istream12EmitInternalIjEEvT_: 34| 417k|void WABT_VECTORCALL Istream::EmitInternal(T val) { 35| 417k| EmitAt(end(), val); 36| 417k|} _ZN4wabt6interp7Istream12EmitInternalIhEEvT_: 34| 1.38k|void WABT_VECTORCALL Istream::EmitInternal(T val) { 35| 1.38k| EmitAt(end(), val); 36| 1.38k|} _ZN4wabt6interp7Istream6EmitAtIhEEvjT_: 25| 1.38k|void WABT_VECTORCALL Istream::EmitAt(Offset offset, T val) { 26| 1.38k| u32 new_size = offset + sizeof(T); 27| 1.38k| if (new_size > data_.size()) { ------------------ | Branch (27:7): [True: 1.38k, False: 0] ------------------ 28| 1.38k| data_.resize(new_size); 29| 1.38k| } 30| 1.38k| memcpy(data_.data() + offset, &val, sizeof(val)); 31| 1.38k|} _ZN4wabt6interp7Istream12EmitInternalImEEvT_: 34| 710|void WABT_VECTORCALL Istream::EmitInternal(T val) { 35| 710| EmitAt(end(), val); 36| 710|} _ZN4wabt6interp7Istream6EmitAtImEEvjT_: 25| 710|void WABT_VECTORCALL Istream::EmitAt(Offset offset, T val) { 26| 710| u32 new_size = offset + sizeof(T); 27| 710| if (new_size > data_.size()) { ------------------ | Branch (27:7): [True: 710, False: 0] ------------------ 28| 710| data_.resize(new_size); 29| 710| } 30| 710| memcpy(data_.data() + offset, &val, sizeof(val)); 31| 710|} _ZN4wabt6interp7Istream12EmitInternalI4v128EEvT_: 34| 22|void WABT_VECTORCALL Istream::EmitInternal(T val) { 35| 22| EmitAt(end(), val); 36| 22|} _ZN4wabt6interp7Istream6EmitAtI4v128EEvjT_: 25| 22|void WABT_VECTORCALL Istream::EmitAt(Offset offset, T val) { 26| 22| u32 new_size = offset + sizeof(T); 27| 22| if (new_size > data_.size()) { ------------------ | Branch (27:7): [True: 22, False: 0] ------------------ 28| 22| data_.resize(new_size); 29| 22| } 30| 22| memcpy(data_.data() + offset, &val, sizeof(val)); 31| 22|} _ZN4wabt6interp7Istream6EmitAtIjEEvjT_: 25| 418k|void WABT_VECTORCALL Istream::EmitAt(Offset offset, T val) { 26| 418k| u32 new_size = offset + sizeof(T); 27| 418k| if (new_size > data_.size()) { ------------------ | Branch (27:7): [True: 417k, False: 598] ------------------ 28| 417k| data_.resize(new_size); 29| 417k| } 30| 418k| memcpy(data_.data() + offset, &val, sizeof(val)); 31| 418k|} _ZN4wabt3VarC2Ev: 589| 54.2k|Var::Var() : Var(kInvalidIndex, Location()) {} _ZN4wabt3VarC2EjRKNS_8LocationE: 592| 82.8k| : loc(loc), type_(VarType::Index), index_(index) {} _ZN4wabt3VarC2EOS0_: 597| 5|Var::Var(Var&& rhs) : Var() { 598| 5| *this = std::move(rhs); 599| 5|} _ZN4wabt3VarC2ERKS0_: 601| 54.2k|Var::Var(const Var& rhs) : Var() { 602| 54.2k| *this = rhs; 603| 54.2k|} _ZN4wabt3VaraSEOS0_: 605| 5|Var& Var::operator=(Var&& rhs) { 606| 5| loc = rhs.loc; 607| 5| if (rhs.is_index()) { ------------------ | Branch (607:7): [True: 5, False: 0] ------------------ 608| 5| set_index(rhs.index_); 609| 5| } else { 610| 0| set_name(rhs.name_); 611| 0| } 612| 5| return *this; 613| 5|} _ZN4wabt3VaraSERKS0_: 615| 54.2k|Var& Var::operator=(const Var& rhs) { 616| 54.2k| loc = rhs.loc; 617| 54.2k| if (rhs.is_index()) { ------------------ | Branch (617:7): [True: 54.2k, False: 0] ------------------ 618| 54.2k| set_index(rhs.index_); 619| 54.2k| } else { 620| 0| set_name(rhs.name_); 621| 0| } 622| 54.2k| return *this; 623| 54.2k|} _ZN4wabt3VarD2Ev: 625| 82.8k|Var::~Var() { 626| 82.8k| Destroy(); 627| 82.8k|} _ZN4wabt3Var9set_indexEj: 629| 54.2k|void Var::set_index(Index index) { 630| 54.2k| Destroy(); 631| 54.2k| type_ = VarType::Index; 632| 54.2k| index_ = index; 633| 54.2k|} _ZN4wabt3Var7DestroyEv: 645| 137k|void Var::Destroy() { 646| 137k| if (is_name()) { ------------------ | Branch (646:7): [True: 0, False: 137k] ------------------ 647| 0| Destruct(name_); 648| 0| } 649| 137k|} _ZN4wabt17WriteU32Leb128RawEPhS0_j: 86| 20|Offset WriteU32Leb128Raw(uint8_t* dest, uint8_t* dest_end, uint32_t value) { 87| 20| uint8_t data[MAX_U32_LEB128_BYTES]; 88| 20| Offset length = 0; 89| 20| LEB128_LOOP_UNTIL(value == 0); ------------------ | | 38| 37| do { \ | | 39| 37| uint8_t byte = value & 0x7f; \ | | 40| 37| value >>= 7; \ | | 41| 37| if (end_cond) { \ | | ------------------ | | | Branch (41:9): [True: 20, False: 17] | | ------------------ | | 42| 20| data[length++] = byte; \ | | 43| 20| break; \ | | 44| 20| } else { \ | | 45| 17| data[length++] = byte | 0x80; \ | | 46| 17| } \ | | 47| 37| } while (1) | | ------------------ | | | Branch (47:12): [Folded - Ignored] | | ------------------ ------------------ 90| 20| if (static_cast(dest_end - dest) < length) { ------------------ | Branch (90:7): [True: 0, False: 20] ------------------ 91| 0| return 0; 92| 0| } 93| 20| memcpy(dest, data, length); 94| 20| return length; 95| 20|} _ZN4wabt13ReadU32Leb128EPKhS1_Pj: 184| 5.09M| uint32_t* out_value) { 185| 5.09M| if (p < end && (p[0] & 0x80) == 0) { ------------------ | Branch (185:7): [True: 3.19M, False: 1.89M] | Branch (185:18): [True: 2.13M, False: 1.05M] ------------------ 186| 2.13M| *out_value = LEB128_1(uint32_t); ------------------ | | 166| 2.13M|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | ------------------ | | | | 164| 2.13M|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ ------------------ 187| 2.13M| return 1; 188| 2.95M| } else if (p + 1 < end && (p[1] & 0x80) == 0) { ------------------ | Branch (188:14): [True: 1.05M, False: 1.89M] | Branch (188:29): [True: 947k, False: 110k] ------------------ 189| 947k| *out_value = LEB128_2(uint32_t); ------------------ | | 167| 947k|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | ------------------ | | | | 164| 947k|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | ------------------ | | | | 166| 947k|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | ------------------ | | | | | | 164| 947k|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | ------------------ ------------------ 190| 947k| return 2; 191| 2.00M| } else if (p + 2 < end && (p[2] & 0x80) == 0) { ------------------ | Branch (191:14): [True: 109k, False: 1.89M] | Branch (191:29): [True: 96.9k, False: 12.6k] ------------------ 192| 96.9k| *out_value = LEB128_3(uint32_t); ------------------ | | 168| 96.9k|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | ------------------ | | | | 164| 96.9k|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | ------------------ | | | | 167| 96.9k|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | ------------------ | | | | | | 164| 96.9k|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | ------------------ | | | | | | 166| 96.9k|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | ------------------ | | | | | | | | 164| 96.9k|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 193| 96.9k| return 3; 194| 1.91M| } else if (p + 3 < end && (p[3] & 0x80) == 0) { ------------------ | Branch (194:14): [True: 12.5k, False: 1.89M] | Branch (194:29): [True: 780, False: 11.8k] ------------------ 195| 780| *out_value = LEB128_4(uint32_t); ------------------ | | 169| 780|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | ------------------ | | | | 164| 780|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | ------------------ | | | | 168| 780|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | ------------------ | | | | | | 164| 780|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | ------------------ | | | | | | 167| 780|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | ------------------ | | | | | | | | 164| 780|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | ------------------ | | | | | | | | 166| 780|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | ------------------ | | | | | | | | | | 164| 780|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 196| 780| return 4; 197| 1.91M| } else if (p + 4 < end && (p[4] & 0x80) == 0) { ------------------ | Branch (197:14): [True: 11.8k, False: 1.89M] | Branch (197:29): [True: 321, False: 11.4k] ------------------ 198| | // The top bits set represent values > 32 bits. 199| 321| if (p[4] & 0xf0) { ------------------ | Branch (199:9): [True: 14, False: 307] ------------------ 200| 14| return 0; 201| 14| } 202| 307| *out_value = LEB128_5(uint32_t); ------------------ | | 170| 307|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | ------------------ | | | | 164| 307|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | ------------------ | | | | 169| 307|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | ------------------ | | | | | | 164| 307|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | ------------------ | | | | | | 168| 307|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | ------------------ | | | | | | | | 164| 307|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | ------------------ | | | | | | | | 167| 307|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 307|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | ------------------ | | | | | | | | | | 166| 307|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 307|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 203| 307| return 5; 204| 1.91M| } else { 205| | // past the end. 206| 1.91M| *out_value = 0; 207| 1.91M| return 0; 208| 1.91M| } 209| 5.09M|} _ZN4wabt13ReadU64Leb128EPKhS1_Pm: 213| 3.58k| uint64_t* out_value) { 214| 3.58k| if (p < end && (p[0] & 0x80) == 0) { ------------------ | Branch (214:7): [True: 3.58k, False: 0] | Branch (214:18): [True: 2.45k, False: 1.12k] ------------------ 215| 2.45k| *out_value = LEB128_1(uint64_t); ------------------ | | 166| 2.45k|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | ------------------ | | | | 164| 2.45k|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ ------------------ 216| 2.45k| return 1; 217| 2.45k| } else if (p + 1 < end && (p[1] & 0x80) == 0) { ------------------ | Branch (217:14): [True: 1.12k, False: 1] | Branch (217:29): [True: 56, False: 1.07k] ------------------ 218| 56| *out_value = LEB128_2(uint64_t); ------------------ | | 167| 56|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | ------------------ | | | | 164| 56|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | ------------------ | | | | 166| 56|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | ------------------ | | | | | | 164| 56|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | ------------------ ------------------ 219| 56| return 2; 220| 1.07k| } else if (p + 2 < end && (p[2] & 0x80) == 0) { ------------------ | Branch (220:14): [True: 1.07k, False: 1] | Branch (220:29): [True: 589, False: 483] ------------------ 221| 589| *out_value = LEB128_3(uint64_t); ------------------ | | 168| 589|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | ------------------ | | | | 164| 589|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | ------------------ | | | | 167| 589|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | ------------------ | | | | | | 164| 589|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | ------------------ | | | | | | 166| 589|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | ------------------ | | | | | | | | 164| 589|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 222| 589| return 3; 223| 589| } else if (p + 3 < end && (p[3] & 0x80) == 0) { ------------------ | Branch (223:14): [True: 483, False: 1] | Branch (223:29): [True: 85, False: 398] ------------------ 224| 85| *out_value = LEB128_4(uint64_t); ------------------ | | 169| 85|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | ------------------ | | | | 164| 85|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | ------------------ | | | | 168| 85|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | ------------------ | | | | | | 164| 85|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | ------------------ | | | | | | 167| 85|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | ------------------ | | | | | | | | 164| 85|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | ------------------ | | | | | | | | 166| 85|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | ------------------ | | | | | | | | | | 164| 85|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 225| 85| return 4; 226| 399| } else if (p + 4 < end && (p[4] & 0x80) == 0) { ------------------ | Branch (226:14): [True: 398, False: 1] | Branch (226:29): [True: 394, False: 4] ------------------ 227| 394| *out_value = LEB128_5(uint64_t); ------------------ | | 170| 394|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | ------------------ | | | | 164| 394|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | ------------------ | | | | 169| 394|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | ------------------ | | | | | | 164| 394|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | ------------------ | | | | | | 168| 394|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | ------------------ | | | | | | | | 164| 394|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | ------------------ | | | | | | | | 167| 394|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 394|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | ------------------ | | | | | | | | | | 166| 394|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 394|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 228| 394| return 5; 229| 394| } else if (p + 5 < end && (p[5] & 0x80) == 0) { ------------------ | Branch (229:14): [True: 4, False: 1] | Branch (229:29): [True: 1, False: 3] ------------------ 230| 1| *out_value = LEB128_6(uint64_t); ------------------ | | 171| 1|#define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | ------------------ | | | | 164| 1|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | ------------------ | | | | 170| 1|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | ------------------ | | | | | | 164| 1|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | ------------------ | | | | | | 169| 1|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | ------------------ | | | | | | | | 164| 1|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | ------------------ | | | | | | | | 168| 1|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 1|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | ------------------ | | | | | | | | | | 167| 1|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 1|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 166| 1|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 164| 1|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 231| 1| return 6; 232| 4| } else if (p + 6 < end && (p[6] & 0x80) == 0) { ------------------ | Branch (232:14): [True: 3, False: 1] | Branch (232:29): [True: 0, False: 3] ------------------ 233| 0| *out_value = LEB128_7(uint64_t); ------------------ | | 172| 0|#define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | ------------------ | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | ------------------ | | | | 171| 0|#define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | ------------------ | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | ------------------ | | | | | | 170| 0|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | ------------------ | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | ------------------ | | | | | | | | 169| 0|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | ------------------ | | | | | | | | | | 168| 0|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 167| 0|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 166| 0|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 234| 0| return 7; 235| 4| } else if (p + 7 < end && (p[7] & 0x80) == 0) { ------------------ | Branch (235:14): [True: 3, False: 1] | Branch (235:29): [True: 3, False: 0] ------------------ 236| 3| *out_value = LEB128_8(uint64_t); ------------------ | | 173| 3|#define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | ------------------ | | | | 164| 3|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | ------------------ | | | | 172| 3|#define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | ------------------ | | | | | | 164| 3|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | ------------------ | | | | | | 171| 3|#define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | ------------------ | | | | | | | | 164| 3|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | ------------------ | | | | | | | | 170| 3|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 3|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | ------------------ | | | | | | | | | | 169| 3|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 3|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 168| 3|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 164| 3|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 167| 3|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 164| 3|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 166| 3|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 164| 3|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 237| 3| return 8; 238| 3| } else if (p + 8 < end && (p[8] & 0x80) == 0) { ------------------ | Branch (238:14): [True: 0, False: 1] | Branch (238:29): [True: 0, False: 0] ------------------ 239| 0| *out_value = LEB128_9(uint64_t); ------------------ | | 174| 0|#define LEB128_9(type) (BYTE_AT(type, 8, 56) | LEB128_8(type)) | | ------------------ | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_9(type) (BYTE_AT(type, 8, 56) | LEB128_8(type)) | | ------------------ | | | | 173| 0|#define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | | | ------------------ | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | | | ------------------ | | | | | | 172| 0|#define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | | | ------------------ | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | | | ------------------ | | | | | | | | 171| 0|#define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | | | ------------------ | | | | | | | | | | 170| 0|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 169| 0|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 168| 0|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 167| 0|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 166| 0|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 240| 0| return 9; 241| 1| } else if (p + 9 < end && (p[9] & 0x80) == 0) { ------------------ | Branch (241:14): [True: 0, False: 1] | Branch (241:29): [True: 0, False: 0] ------------------ 242| | // The top bits set represent values > 64 bits. 243| 0| if (p[9] & 0xfe) { ------------------ | Branch (243:9): [True: 0, False: 0] ------------------ 244| 0| return 0; 245| 0| } 246| 0| *out_value = LEB128_10(uint64_t); ------------------ | | 175| 0|#define LEB128_10(type) (BYTE_AT(type, 9, 63) | LEB128_9(type)) | | ------------------ | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_10(type) (BYTE_AT(type, 9, 63) | LEB128_9(type)) | | ------------------ | | | | 174| 0|#define LEB128_9(type) (BYTE_AT(type, 8, 56) | LEB128_8(type)) | | | | ------------------ | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_9(type) (BYTE_AT(type, 8, 56) | LEB128_8(type)) | | | | ------------------ | | | | | | 173| 0|#define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | | | | | ------------------ | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | | | | | ------------------ | | | | | | | | 172| 0|#define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | | | | | ------------------ | | | | | | | | | | 171| 0|#define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | | | #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 170| 0|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 169| 0|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 168| 0|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 167| 0|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 166| 0|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 247| 0| return 10; 248| 1| } else { 249| | // past the end. 250| 1| *out_value = 0; 251| 1| return 0; 252| 1| } 253| 3.58k|} _ZN4wabt13ReadS32Leb128EPKhS1_Pj: 257| 47.5k| uint32_t* out_value) { 258| 47.5k| if (p < end && (p[0] & 0x80) == 0) { ------------------ | Branch (258:7): [True: 47.2k, False: 355] | Branch (258:18): [True: 40.7k, False: 6.46k] ------------------ 259| 40.7k| uint32_t result = LEB128_1(uint32_t); ------------------ | | 166| 40.7k|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | ------------------ | | | | 164| 40.7k|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ ------------------ 260| 40.7k| *out_value = SIGN_EXTEND(int32_t, result, 6); ------------------ | | 179| 40.7k| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 40.7k|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 40.7k| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 40.7k|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 261| 40.7k| return 1; 262| 40.7k| } else if (p + 1 < end && (p[1] & 0x80) == 0) { ------------------ | Branch (262:14): [True: 6.46k, False: 364] | Branch (262:29): [True: 3.76k, False: 2.69k] ------------------ 263| 3.76k| uint32_t result = LEB128_2(uint32_t); ------------------ | | 167| 3.76k|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | ------------------ | | | | 164| 3.76k|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | ------------------ | | | | 166| 3.76k|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | ------------------ | | | | | | 164| 3.76k|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | ------------------ ------------------ 264| 3.76k| *out_value = SIGN_EXTEND(int32_t, result, 13); ------------------ | | 179| 3.76k| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 3.76k|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 3.76k| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 3.76k|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 265| 3.76k| return 2; 266| 3.76k| } else if (p + 2 < end && (p[2] & 0x80) == 0) { ------------------ | Branch (266:14): [True: 2.69k, False: 364] | Branch (266:29): [True: 857, False: 1.83k] ------------------ 267| 857| uint32_t result = LEB128_3(uint32_t); ------------------ | | 168| 857|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | ------------------ | | | | 164| 857|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | ------------------ | | | | 167| 857|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | ------------------ | | | | | | 164| 857|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | ------------------ | | | | | | 166| 857|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | ------------------ | | | | | | | | 164| 857|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 268| 857| *out_value = SIGN_EXTEND(int32_t, result, 20); ------------------ | | 179| 857| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 857|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 857| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 857|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 269| 857| return 3; 270| 2.19k| } else if (p + 3 < end && (p[3] & 0x80) == 0) { ------------------ | Branch (270:14): [True: 1.83k, False: 364] | Branch (270:29): [True: 713, False: 1.12k] ------------------ 271| 713| uint32_t result = LEB128_4(uint32_t); ------------------ | | 169| 713|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | ------------------ | | | | 164| 713|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | ------------------ | | | | 168| 713|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | ------------------ | | | | | | 164| 713|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | ------------------ | | | | | | 167| 713|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | ------------------ | | | | | | | | 164| 713|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | ------------------ | | | | | | | | 166| 713|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | ------------------ | | | | | | | | | | 164| 713|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 272| 713| *out_value = SIGN_EXTEND(int32_t, result, 27); ------------------ | | 179| 713| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 713|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 713| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 713|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 273| 713| return 4; 274| 1.48k| } else if (p + 4 < end && (p[4] & 0x80) == 0) { ------------------ | Branch (274:14): [True: 1.12k, False: 364] | Branch (274:29): [True: 1.08k, False: 35] ------------------ 275| | // The top bits should be a sign-extension of the sign bit. 276| 1.08k| bool sign_bit_set = (p[4] & 0x8); 277| 1.08k| int top_bits = p[4] & 0xf0; 278| 1.08k| if ((sign_bit_set && top_bits != 0x70) || ------------------ | Branch (278:10): [True: 877, False: 210] | Branch (278:26): [True: 861, False: 16] ------------------ 279| 1.08k| (!sign_bit_set && top_bits != 0)) { ------------------ | Branch (279:10): [True: 210, False: 16] | Branch (279:27): [True: 191, False: 19] ------------------ 280| 1.05k| return 0; 281| 1.05k| } 282| 35| uint32_t result = LEB128_5(uint32_t); ------------------ | | 170| 35|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | ------------------ | | | | 164| 35|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | ------------------ | | | | 169| 35|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | ------------------ | | | | | | 164| 35|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | ------------------ | | | | | | 168| 35|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | ------------------ | | | | | | | | 164| 35|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | ------------------ | | | | | | | | 167| 35|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 35|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | ------------------ | | | | | | | | | | 166| 35|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 35|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 283| 35| *out_value = result; 284| 35| return 5; 285| 1.08k| } else { 286| | // Past the end. 287| 399| return 0; 288| 399| } 289| 47.5k|} _ZN4wabt13ReadS64Leb128EPKhS1_Pm: 293| 574| uint64_t* out_value) { 294| 574| if (p < end && (p[0] & 0x80) == 0) { ------------------ | Branch (294:7): [True: 574, False: 0] | Branch (294:18): [True: 557, False: 17] ------------------ 295| 557| uint64_t result = LEB128_1(uint64_t); ------------------ | | 166| 557|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | ------------------ | | | | 164| 557|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ ------------------ 296| 557| *out_value = SIGN_EXTEND(int64_t, result, 6); ------------------ | | 179| 557| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 557|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 557| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 557|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 297| 557| return 1; 298| 557| } else if (p + 1 < end && (p[1] & 0x80) == 0) { ------------------ | Branch (298:14): [True: 17, False: 0] | Branch (298:29): [True: 17, False: 0] ------------------ 299| 17| uint64_t result = LEB128_2(uint64_t); ------------------ | | 167| 17|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | ------------------ | | | | 164| 17|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | ------------------ | | | | 166| 17|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | ------------------ | | | | | | 164| 17|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | ------------------ ------------------ 300| 17| *out_value = SIGN_EXTEND(int64_t, result, 13); ------------------ | | 179| 17| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 17|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 17| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 17|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 301| 17| return 2; 302| 17| } else if (p + 2 < end && (p[2] & 0x80) == 0) { ------------------ | Branch (302:14): [True: 0, False: 0] | Branch (302:29): [True: 0, False: 0] ------------------ 303| 0| uint64_t result = LEB128_3(uint64_t); ------------------ | | 168| 0|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | ------------------ | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | ------------------ | | | | 167| 0|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | ------------------ | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | ------------------ | | | | | | 166| 0|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | ------------------ | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 304| 0| *out_value = SIGN_EXTEND(int64_t, result, 20); ------------------ | | 179| 0| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 0| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 305| 0| return 3; 306| 0| } else if (p + 3 < end && (p[3] & 0x80) == 0) { ------------------ | Branch (306:14): [True: 0, False: 0] | Branch (306:29): [True: 0, False: 0] ------------------ 307| 0| uint64_t result = LEB128_4(uint64_t); ------------------ | | 169| 0|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | ------------------ | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | ------------------ | | | | 168| 0|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | ------------------ | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | ------------------ | | | | | | 167| 0|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | ------------------ | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | ------------------ | | | | | | | | 166| 0|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | ------------------ | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 308| 0| *out_value = SIGN_EXTEND(int64_t, result, 27); ------------------ | | 179| 0| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 0| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 309| 0| return 4; 310| 0| } else if (p + 4 < end && (p[4] & 0x80) == 0) { ------------------ | Branch (310:14): [True: 0, False: 0] | Branch (310:29): [True: 0, False: 0] ------------------ 311| 0| uint64_t result = LEB128_5(uint64_t); ------------------ | | 170| 0|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | ------------------ | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | ------------------ | | | | 169| 0|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | ------------------ | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | ------------------ | | | | | | 168| 0|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | ------------------ | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | ------------------ | | | | | | | | 167| 0|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | ------------------ | | | | | | | | | | 166| 0|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 312| 0| *out_value = SIGN_EXTEND(int64_t, result, 34); ------------------ | | 179| 0| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 0| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 313| 0| return 5; 314| 0| } else if (p + 5 < end && (p[5] & 0x80) == 0) { ------------------ | Branch (314:14): [True: 0, False: 0] | Branch (314:29): [True: 0, False: 0] ------------------ 315| 0| uint64_t result = LEB128_6(uint64_t); ------------------ | | 171| 0|#define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | ------------------ | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | ------------------ | | | | 170| 0|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | ------------------ | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | ------------------ | | | | | | 169| 0|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | ------------------ | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | ------------------ | | | | | | | | 168| 0|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | ------------------ | | | | | | | | | | 167| 0|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 166| 0|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 316| 0| *out_value = SIGN_EXTEND(int64_t, result, 41); ------------------ | | 179| 0| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 0| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 317| 0| return 6; 318| 0| } else if (p + 6 < end && (p[6] & 0x80) == 0) { ------------------ | Branch (318:14): [True: 0, False: 0] | Branch (318:29): [True: 0, False: 0] ------------------ 319| 0| uint64_t result = LEB128_7(uint64_t); ------------------ | | 172| 0|#define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | ------------------ | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | ------------------ | | | | 171| 0|#define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | ------------------ | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | ------------------ | | | | | | 170| 0|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | ------------------ | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | ------------------ | | | | | | | | 169| 0|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | ------------------ | | | | | | | | | | 168| 0|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 167| 0|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 166| 0|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 320| 0| *out_value = SIGN_EXTEND(int64_t, result, 48); ------------------ | | 179| 0| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 0| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 321| 0| return 7; 322| 0| } else if (p + 7 < end && (p[7] & 0x80) == 0) { ------------------ | Branch (322:14): [True: 0, False: 0] | Branch (322:29): [True: 0, False: 0] ------------------ 323| 0| uint64_t result = LEB128_8(uint64_t); ------------------ | | 173| 0|#define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | ------------------ | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | ------------------ | | | | 172| 0|#define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | ------------------ | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | ------------------ | | | | | | 171| 0|#define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | ------------------ | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | ------------------ | | | | | | | | 170| 0|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | ------------------ | | | | | | | | | | 169| 0|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 168| 0|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 167| 0|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 166| 0|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 324| 0| *out_value = SIGN_EXTEND(int64_t, result, 55); ------------------ | | 179| 0| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 0| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 325| 0| return 8; 326| 0| } else if (p + 8 < end && (p[8] & 0x80) == 0) { ------------------ | Branch (326:14): [True: 0, False: 0] | Branch (326:29): [True: 0, False: 0] ------------------ 327| 0| uint64_t result = LEB128_9(uint64_t); ------------------ | | 174| 0|#define LEB128_9(type) (BYTE_AT(type, 8, 56) | LEB128_8(type)) | | ------------------ | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_9(type) (BYTE_AT(type, 8, 56) | LEB128_8(type)) | | ------------------ | | | | 173| 0|#define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | | | ------------------ | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | | | ------------------ | | | | | | 172| 0|#define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | | | ------------------ | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | | | ------------------ | | | | | | | | 171| 0|#define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | | | ------------------ | | | | | | | | | | 170| 0|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 169| 0|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 168| 0|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 167| 0|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 166| 0|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 328| 0| *out_value = SIGN_EXTEND(int64_t, result, 62); ------------------ | | 179| 0| (static_cast((value) << SHIFT_AMOUNT(type, sign_bit)) >> \ | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ | | 180| 0| SHIFT_AMOUNT(type, sign_bit)) | | ------------------ | | | | 177| 0|#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit)) | | ------------------ ------------------ 329| 0| return 9; 330| 0| } else if (p + 9 < end && (p[9] & 0x80) == 0) { ------------------ | Branch (330:14): [True: 0, False: 0] | Branch (330:29): [True: 0, False: 0] ------------------ 331| | // The top bits should be a sign-extension of the sign bit. 332| 0| bool sign_bit_set = (p[9] & 0x1); 333| 0| int top_bits = p[9] & 0xfe; 334| 0| if ((sign_bit_set && top_bits != 0x7e) || ------------------ | Branch (334:10): [True: 0, False: 0] | Branch (334:26): [True: 0, False: 0] ------------------ 335| 0| (!sign_bit_set && top_bits != 0)) { ------------------ | Branch (335:10): [True: 0, False: 0] | Branch (335:27): [True: 0, False: 0] ------------------ 336| 0| return 0; 337| 0| } 338| 0| uint64_t result = LEB128_10(uint64_t); ------------------ | | 175| 0|#define LEB128_10(type) (BYTE_AT(type, 9, 63) | LEB128_9(type)) | | ------------------ | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | ------------------ | | #define LEB128_10(type) (BYTE_AT(type, 9, 63) | LEB128_9(type)) | | ------------------ | | | | 174| 0|#define LEB128_9(type) (BYTE_AT(type, 8, 56) | LEB128_8(type)) | | | | ------------------ | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | ------------------ | | | | #define LEB128_9(type) (BYTE_AT(type, 8, 56) | LEB128_8(type)) | | | | ------------------ | | | | | | 173| 0|#define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | | | | | ------------------ | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | ------------------ | | | | | | #define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type)) | | | | | | ------------------ | | | | | | | | 172| 0|#define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | | | | | ------------------ | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | ------------------ | | | | | | | | #define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type)) | | | | | | | | ------------------ | | | | | | | | | | 171| 0|#define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | ------------------ | | | | | | | | | | #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 170| 0|#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 169| 0|#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type)) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 168| 0|#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type)) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 167| 0|#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type)) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 166| 0|#define LEB128_1(type) (BYTE_AT(type, 0, 0)) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 164| 0|#define BYTE_AT(type, i, shift) ((static_cast(p[i]) & 0x7f) << (shift)) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 339| 0| *out_value = result; 340| 0| return 10; 341| 0| } else { 342| | // Past the end. 343| 0| return 0; 344| 0| } 345| 574|} _ZNK4wabt6Opcode7GetInfoEv: 41| 413k|Opcode::Info Opcode::GetInfo() const { 42| 413k| if (enum_ < Invalid) { ------------------ | Branch (42:7): [True: 413k, False: 182] ------------------ 43| 413k| return infos_[enum_]; 44| 413k| } 45| | 46| 182| Info invalid_info = infos_[Opcode::Invalid]; 47| 182| DecodeInvalidOpcode(enum_, &invalid_info.prefix, &invalid_info.code); 48| 182| invalid_info.prefix_code = PrefixCode(invalid_info.prefix, invalid_info.code); 49| 182| return invalid_info; 50| 413k|} _ZNK4wabt6Opcode9IsEnabledERKNS_8FeaturesE: 64| 379k|bool Opcode::IsEnabled(const Features& features) const { 65| 379k| switch (enum_) { 66| 6| case Opcode::Try: ------------------ | Branch (66:5): [True: 6, False: 379k] ------------------ 67| 11| case Opcode::Catch: ------------------ | Branch (67:5): [True: 5, False: 379k] ------------------ 68| 15| case Opcode::Delegate: ------------------ | Branch (68:5): [True: 4, False: 379k] ------------------ 69| 19| case Opcode::Throw: ------------------ | Branch (69:5): [True: 4, False: 379k] ------------------ 70| 25| case Opcode::Rethrow: ------------------ | Branch (70:5): [True: 6, False: 379k] ------------------ 71| 25| return features.exceptions_enabled(); 72| | 73| 115| case Opcode::ReturnCallIndirect: ------------------ | Branch (73:5): [True: 115, False: 379k] ------------------ 74| 118| case Opcode::ReturnCall: ------------------ | Branch (74:5): [True: 3, False: 379k] ------------------ 75| 118| return features.tail_call_enabled(); 76| | 77| 226| case Opcode::I32TruncSatF32S: ------------------ | Branch (77:5): [True: 226, False: 379k] ------------------ 78| 2.13k| case Opcode::I32TruncSatF32U: ------------------ | Branch (78:5): [True: 1.91k, False: 377k] ------------------ 79| 2.13k| case Opcode::I32TruncSatF64S: ------------------ | Branch (79:5): [True: 0, False: 379k] ------------------ 80| 2.13k| case Opcode::I32TruncSatF64U: ------------------ | Branch (80:5): [True: 0, False: 379k] ------------------ 81| 2.13k| case Opcode::I64TruncSatF32S: ------------------ | Branch (81:5): [True: 0, False: 379k] ------------------ 82| 2.23k| case Opcode::I64TruncSatF32U: ------------------ | Branch (82:5): [True: 102, False: 379k] ------------------ 83| 2.39k| case Opcode::I64TruncSatF64S: ------------------ | Branch (83:5): [True: 160, False: 379k] ------------------ 84| 2.40k| case Opcode::I64TruncSatF64U: ------------------ | Branch (84:5): [True: 4, False: 379k] ------------------ 85| 2.40k| return features.sat_float_to_int_enabled(); 86| | 87| 4.93k| case Opcode::I32Extend8S: ------------------ | Branch (87:5): [True: 4.93k, False: 374k] ------------------ 88| 5.06k| case Opcode::I32Extend16S: ------------------ | Branch (88:5): [True: 135, False: 379k] ------------------ 89| 5.07k| case Opcode::I64Extend8S: ------------------ | Branch (89:5): [True: 4, False: 379k] ------------------ 90| 5.07k| case Opcode::I64Extend16S: ------------------ | Branch (90:5): [True: 0, False: 379k] ------------------ 91| 5.08k| case Opcode::I64Extend32S: ------------------ | Branch (91:5): [True: 11, False: 379k] ------------------ 92| 5.08k| return features.sign_extension_enabled(); 93| | 94| 1| case Opcode::MemoryAtomicNotify: ------------------ | Branch (94:5): [True: 1, False: 379k] ------------------ 95| 1| case Opcode::MemoryAtomicWait32: ------------------ | Branch (95:5): [True: 0, False: 379k] ------------------ 96| 1| case Opcode::MemoryAtomicWait64: ------------------ | Branch (96:5): [True: 0, False: 379k] ------------------ 97| 235| case Opcode::AtomicFence: ------------------ | Branch (97:5): [True: 234, False: 379k] ------------------ 98| 235| case Opcode::I32AtomicLoad: ------------------ | Branch (98:5): [True: 0, False: 379k] ------------------ 99| 235| case Opcode::I64AtomicLoad: ------------------ | Branch (99:5): [True: 0, False: 379k] ------------------ 100| 235| case Opcode::I32AtomicLoad8U: ------------------ | Branch (100:5): [True: 0, False: 379k] ------------------ 101| 235| case Opcode::I32AtomicLoad16U: ------------------ | Branch (101:5): [True: 0, False: 379k] ------------------ 102| 235| case Opcode::I64AtomicLoad8U: ------------------ | Branch (102:5): [True: 0, False: 379k] ------------------ 103| 235| case Opcode::I64AtomicLoad16U: ------------------ | Branch (103:5): [True: 0, False: 379k] ------------------ 104| 235| case Opcode::I64AtomicLoad32U: ------------------ | Branch (104:5): [True: 0, False: 379k] ------------------ 105| 235| case Opcode::I32AtomicStore: ------------------ | Branch (105:5): [True: 0, False: 379k] ------------------ 106| 235| case Opcode::I64AtomicStore: ------------------ | Branch (106:5): [True: 0, False: 379k] ------------------ 107| 236| case Opcode::I32AtomicStore8: ------------------ | Branch (107:5): [True: 1, False: 379k] ------------------ 108| 236| case Opcode::I32AtomicStore16: ------------------ | Branch (108:5): [True: 0, False: 379k] ------------------ 109| 236| case Opcode::I64AtomicStore8: ------------------ | Branch (109:5): [True: 0, False: 379k] ------------------ 110| 236| case Opcode::I64AtomicStore16: ------------------ | Branch (110:5): [True: 0, False: 379k] ------------------ 111| 236| case Opcode::I64AtomicStore32: ------------------ | Branch (111:5): [True: 0, False: 379k] ------------------ 112| 236| case Opcode::I32AtomicRmwAdd: ------------------ | Branch (112:5): [True: 0, False: 379k] ------------------ 113| 236| case Opcode::I64AtomicRmwAdd: ------------------ | Branch (113:5): [True: 0, False: 379k] ------------------ 114| 236| case Opcode::I32AtomicRmw8AddU: ------------------ | Branch (114:5): [True: 0, False: 379k] ------------------ 115| 236| case Opcode::I32AtomicRmw16AddU: ------------------ | Branch (115:5): [True: 0, False: 379k] ------------------ 116| 236| case Opcode::I64AtomicRmw8AddU: ------------------ | Branch (116:5): [True: 0, False: 379k] ------------------ 117| 236| case Opcode::I64AtomicRmw16AddU: ------------------ | Branch (117:5): [True: 0, False: 379k] ------------------ 118| 236| case Opcode::I64AtomicRmw32AddU: ------------------ | Branch (118:5): [True: 0, False: 379k] ------------------ 119| 236| case Opcode::I32AtomicRmwSub: ------------------ | Branch (119:5): [True: 0, False: 379k] ------------------ 120| 236| case Opcode::I64AtomicRmwSub: ------------------ | Branch (120:5): [True: 0, False: 379k] ------------------ 121| 236| case Opcode::I32AtomicRmw8SubU: ------------------ | Branch (121:5): [True: 0, False: 379k] ------------------ 122| 236| case Opcode::I32AtomicRmw16SubU: ------------------ | Branch (122:5): [True: 0, False: 379k] ------------------ 123| 236| case Opcode::I64AtomicRmw8SubU: ------------------ | Branch (123:5): [True: 0, False: 379k] ------------------ 124| 236| case Opcode::I64AtomicRmw16SubU: ------------------ | Branch (124:5): [True: 0, False: 379k] ------------------ 125| 236| case Opcode::I64AtomicRmw32SubU: ------------------ | Branch (125:5): [True: 0, False: 379k] ------------------ 126| 236| case Opcode::I32AtomicRmwAnd: ------------------ | Branch (126:5): [True: 0, False: 379k] ------------------ 127| 236| case Opcode::I64AtomicRmwAnd: ------------------ | Branch (127:5): [True: 0, False: 379k] ------------------ 128| 236| case Opcode::I32AtomicRmw8AndU: ------------------ | Branch (128:5): [True: 0, False: 379k] ------------------ 129| 236| case Opcode::I32AtomicRmw16AndU: ------------------ | Branch (129:5): [True: 0, False: 379k] ------------------ 130| 236| case Opcode::I64AtomicRmw8AndU: ------------------ | Branch (130:5): [True: 0, False: 379k] ------------------ 131| 236| case Opcode::I64AtomicRmw16AndU: ------------------ | Branch (131:5): [True: 0, False: 379k] ------------------ 132| 236| case Opcode::I64AtomicRmw32AndU: ------------------ | Branch (132:5): [True: 0, False: 379k] ------------------ 133| 236| case Opcode::I32AtomicRmwOr: ------------------ | Branch (133:5): [True: 0, False: 379k] ------------------ 134| 236| case Opcode::I64AtomicRmwOr: ------------------ | Branch (134:5): [True: 0, False: 379k] ------------------ 135| 251| case Opcode::I32AtomicRmw8OrU: ------------------ | Branch (135:5): [True: 15, False: 379k] ------------------ 136| 251| case Opcode::I32AtomicRmw16OrU: ------------------ | Branch (136:5): [True: 0, False: 379k] ------------------ 137| 251| case Opcode::I64AtomicRmw8OrU: ------------------ | Branch (137:5): [True: 0, False: 379k] ------------------ 138| 251| case Opcode::I64AtomicRmw16OrU: ------------------ | Branch (138:5): [True: 0, False: 379k] ------------------ 139| 251| case Opcode::I64AtomicRmw32OrU: ------------------ | Branch (139:5): [True: 0, False: 379k] ------------------ 140| 251| case Opcode::I32AtomicRmwXor: ------------------ | Branch (140:5): [True: 0, False: 379k] ------------------ 141| 251| case Opcode::I64AtomicRmwXor: ------------------ | Branch (141:5): [True: 0, False: 379k] ------------------ 142| 251| case Opcode::I32AtomicRmw8XorU: ------------------ | Branch (142:5): [True: 0, False: 379k] ------------------ 143| 251| case Opcode::I32AtomicRmw16XorU: ------------------ | Branch (143:5): [True: 0, False: 379k] ------------------ 144| 251| case Opcode::I64AtomicRmw8XorU: ------------------ | Branch (144:5): [True: 0, False: 379k] ------------------ 145| 251| case Opcode::I64AtomicRmw16XorU: ------------------ | Branch (145:5): [True: 0, False: 379k] ------------------ 146| 251| case Opcode::I64AtomicRmw32XorU: ------------------ | Branch (146:5): [True: 0, False: 379k] ------------------ 147| 251| case Opcode::I32AtomicRmwXchg: ------------------ | Branch (147:5): [True: 0, False: 379k] ------------------ 148| 251| case Opcode::I64AtomicRmwXchg: ------------------ | Branch (148:5): [True: 0, False: 379k] ------------------ 149| 251| case Opcode::I32AtomicRmw8XchgU: ------------------ | Branch (149:5): [True: 0, False: 379k] ------------------ 150| 251| case Opcode::I32AtomicRmw16XchgU: ------------------ | Branch (150:5): [True: 0, False: 379k] ------------------ 151| 251| case Opcode::I64AtomicRmw8XchgU: ------------------ | Branch (151:5): [True: 0, False: 379k] ------------------ 152| 251| case Opcode::I64AtomicRmw16XchgU: ------------------ | Branch (152:5): [True: 0, False: 379k] ------------------ 153| 251| case Opcode::I64AtomicRmw32XchgU: ------------------ | Branch (153:5): [True: 0, False: 379k] ------------------ 154| 251| case Opcode::I32AtomicRmwCmpxchg: ------------------ | Branch (154:5): [True: 0, False: 379k] ------------------ 155| 251| case Opcode::I64AtomicRmwCmpxchg: ------------------ | Branch (155:5): [True: 0, False: 379k] ------------------ 156| 251| case Opcode::I32AtomicRmw8CmpxchgU: ------------------ | Branch (156:5): [True: 0, False: 379k] ------------------ 157| 251| case Opcode::I32AtomicRmw16CmpxchgU: ------------------ | Branch (157:5): [True: 0, False: 379k] ------------------ 158| 251| case Opcode::I64AtomicRmw8CmpxchgU: ------------------ | Branch (158:5): [True: 0, False: 379k] ------------------ 159| 251| case Opcode::I64AtomicRmw16CmpxchgU: ------------------ | Branch (159:5): [True: 0, False: 379k] ------------------ 160| 251| case Opcode::I64AtomicRmw32CmpxchgU: ------------------ | Branch (160:5): [True: 0, False: 379k] ------------------ 161| 251| return features.threads_enabled(); 162| | 163| 22| case Opcode::V128Const: ------------------ | Branch (163:5): [True: 22, False: 379k] ------------------ 164| 2.65k| case Opcode::V128Load: ------------------ | Branch (164:5): [True: 2.62k, False: 377k] ------------------ 165| 2.67k| case Opcode::V128Store: ------------------ | Branch (165:5): [True: 26, False: 379k] ------------------ 166| 2.80k| case Opcode::I8X16Splat: ------------------ | Branch (166:5): [True: 125, False: 379k] ------------------ 167| 2.80k| case Opcode::I16X8Splat: ------------------ | Branch (167:5): [True: 3, False: 379k] ------------------ 168| 2.80k| case Opcode::I32X4Splat: ------------------ | Branch (168:5): [True: 3, False: 379k] ------------------ 169| 2.80k| case Opcode::I64X2Splat: ------------------ | Branch (169:5): [True: 0, False: 379k] ------------------ 170| 2.83k| case Opcode::F32X4Splat: ------------------ | Branch (170:5): [True: 30, False: 379k] ------------------ 171| 2.83k| case Opcode::F64X2Splat: ------------------ | Branch (171:5): [True: 0, False: 379k] ------------------ 172| 2.84k| case Opcode::I8X16ExtractLaneS: ------------------ | Branch (172:5): [True: 4, False: 379k] ------------------ 173| 2.84k| case Opcode::I8X16ExtractLaneU: ------------------ | Branch (173:5): [True: 0, False: 379k] ------------------ 174| 2.84k| case Opcode::I16X8ExtractLaneS: ------------------ | Branch (174:5): [True: 1, False: 379k] ------------------ 175| 3.02k| case Opcode::I16X8ExtractLaneU: ------------------ | Branch (175:5): [True: 181, False: 379k] ------------------ 176| 3.02k| case Opcode::I32X4ExtractLane: ------------------ | Branch (176:5): [True: 0, False: 379k] ------------------ 177| 3.27k| case Opcode::I64X2ExtractLane: ------------------ | Branch (177:5): [True: 253, False: 379k] ------------------ 178| 3.27k| case Opcode::F32X4ExtractLane: ------------------ | Branch (178:5): [True: 0, False: 379k] ------------------ 179| 3.48k| case Opcode::F64X2ExtractLane: ------------------ | Branch (179:5): [True: 205, False: 379k] ------------------ 180| 3.57k| case Opcode::I8X16ReplaceLane: ------------------ | Branch (180:5): [True: 92, False: 379k] ------------------ 181| 3.85k| case Opcode::I16X8ReplaceLane: ------------------ | Branch (181:5): [True: 284, False: 379k] ------------------ 182| 3.85k| case Opcode::I32X4ReplaceLane: ------------------ | Branch (182:5): [True: 0, False: 379k] ------------------ 183| 3.85k| case Opcode::I64X2ReplaceLane: ------------------ | Branch (183:5): [True: 0, False: 379k] ------------------ 184| 3.86k| case Opcode::F32X4ReplaceLane: ------------------ | Branch (184:5): [True: 5, False: 379k] ------------------ 185| 3.86k| case Opcode::F64X2ReplaceLane: ------------------ | Branch (185:5): [True: 0, False: 379k] ------------------ 186| 3.86k| case Opcode::I8X16Add: ------------------ | Branch (186:5): [True: 0, False: 379k] ------------------ 187| 3.90k| case Opcode::I16X8Add: ------------------ | Branch (187:5): [True: 39, False: 379k] ------------------ 188| 3.90k| case Opcode::I32X4Add: ------------------ | Branch (188:5): [True: 2, False: 379k] ------------------ 189| 3.90k| case Opcode::I64X2Add: ------------------ | Branch (189:5): [True: 0, False: 379k] ------------------ 190| 3.90k| case Opcode::I8X16Sub: ------------------ | Branch (190:5): [True: 5, False: 379k] ------------------ 191| 3.90k| case Opcode::I16X8Sub: ------------------ | Branch (191:5): [True: 0, False: 379k] ------------------ 192| 3.91k| case Opcode::I32X4Sub: ------------------ | Branch (192:5): [True: 2, False: 379k] ------------------ 193| 3.93k| case Opcode::I64X2Sub: ------------------ | Branch (193:5): [True: 21, False: 379k] ------------------ 194| 3.93k| case Opcode::I16X8Mul: ------------------ | Branch (194:5): [True: 0, False: 379k] ------------------ 195| 3.93k| case Opcode::I32X4Mul: ------------------ | Branch (195:5): [True: 3, False: 379k] ------------------ 196| 3.93k| case Opcode::I8X16Neg: ------------------ | Branch (196:5): [True: 0, False: 379k] ------------------ 197| 4.15k| case Opcode::I16X8Neg: ------------------ | Branch (197:5): [True: 219, False: 379k] ------------------ 198| 4.15k| case Opcode::I32X4Neg: ------------------ | Branch (198:5): [True: 0, False: 379k] ------------------ 199| 5.11k| case Opcode::I64X2Neg: ------------------ | Branch (199:5): [True: 960, False: 378k] ------------------ 200| 5.12k| case Opcode::I8X16AddSatS: ------------------ | Branch (200:5): [True: 11, False: 379k] ------------------ 201| 5.12k| case Opcode::I8X16AddSatU: ------------------ | Branch (201:5): [True: 0, False: 379k] ------------------ 202| 5.25k| case Opcode::I16X8AddSatS: ------------------ | Branch (202:5): [True: 131, False: 379k] ------------------ 203| 5.25k| case Opcode::I16X8AddSatU: ------------------ | Branch (203:5): [True: 0, False: 379k] ------------------ 204| 5.25k| case Opcode::I8X16SubSatS: ------------------ | Branch (204:5): [True: 0, False: 379k] ------------------ 205| 5.25k| case Opcode::I8X16SubSatU: ------------------ | Branch (205:5): [True: 1, False: 379k] ------------------ 206| 5.25k| case Opcode::I16X8SubSatS: ------------------ | Branch (206:5): [True: 0, False: 379k] ------------------ 207| 5.25k| case Opcode::I16X8SubSatU: ------------------ | Branch (207:5): [True: 0, False: 379k] ------------------ 208| 5.25k| case Opcode::I8X16Shl: ------------------ | Branch (208:5): [True: 0, False: 379k] ------------------ 209| 5.25k| case Opcode::I16X8Shl: ------------------ | Branch (209:5): [True: 0, False: 379k] ------------------ 210| 5.25k| case Opcode::I32X4Shl: ------------------ | Branch (210:5): [True: 0, False: 379k] ------------------ 211| 5.25k| case Opcode::I64X2Shl: ------------------ | Branch (211:5): [True: 0, False: 379k] ------------------ 212| 5.25k| case Opcode::I8X16ShrS: ------------------ | Branch (212:5): [True: 0, False: 379k] ------------------ 213| 5.25k| case Opcode::I8X16ShrU: ------------------ | Branch (213:5): [True: 0, False: 379k] ------------------ 214| 5.26k| case Opcode::I16X8ShrS: ------------------ | Branch (214:5): [True: 8, False: 379k] ------------------ 215| 5.26k| case Opcode::I16X8ShrU: ------------------ | Branch (215:5): [True: 0, False: 379k] ------------------ 216| 5.26k| case Opcode::I32X4ShrS: ------------------ | Branch (216:5): [True: 0, False: 379k] ------------------ 217| 5.28k| case Opcode::I32X4ShrU: ------------------ | Branch (217:5): [True: 20, False: 379k] ------------------ 218| 5.28k| case Opcode::I64X2ShrS: ------------------ | Branch (218:5): [True: 0, False: 379k] ------------------ 219| 5.28k| case Opcode::I64X2ShrU: ------------------ | Branch (219:5): [True: 0, False: 379k] ------------------ 220| 5.28k| case Opcode::V128And: ------------------ | Branch (220:5): [True: 0, False: 379k] ------------------ 221| 5.28k| case Opcode::V128Or: ------------------ | Branch (221:5): [True: 0, False: 379k] ------------------ 222| 5.28k| case Opcode::V128Xor: ------------------ | Branch (222:5): [True: 1, False: 379k] ------------------ 223| 5.28k| case Opcode::V128Not: ------------------ | Branch (223:5): [True: 0, False: 379k] ------------------ 224| 5.28k| case Opcode::V128BitSelect: ------------------ | Branch (224:5): [True: 0, False: 379k] ------------------ 225| 5.33k| case Opcode::V128AnyTrue: ------------------ | Branch (225:5): [True: 51, False: 379k] ------------------ 226| 5.33k| case Opcode::I8X16Bitmask: ------------------ | Branch (226:5): [True: 0, False: 379k] ------------------ 227| 5.33k| case Opcode::I16X8Bitmask: ------------------ | Branch (227:5): [True: 1, False: 379k] ------------------ 228| 5.33k| case Opcode::I32X4Bitmask: ------------------ | Branch (228:5): [True: 0, False: 379k] ------------------ 229| 5.45k| case Opcode::I64X2Bitmask: ------------------ | Branch (229:5): [True: 113, False: 379k] ------------------ 230| 5.45k| case Opcode::I8X16AllTrue: ------------------ | Branch (230:5): [True: 9, False: 379k] ------------------ 231| 5.46k| case Opcode::I16X8AllTrue: ------------------ | Branch (231:5): [True: 8, False: 379k] ------------------ 232| 5.47k| case Opcode::I32X4AllTrue: ------------------ | Branch (232:5): [True: 8, False: 379k] ------------------ 233| 5.47k| case Opcode::I64X2AllTrue: ------------------ | Branch (233:5): [True: 0, False: 379k] ------------------ 234| 5.47k| case Opcode::I8X16Eq: ------------------ | Branch (234:5): [True: 3, False: 379k] ------------------ 235| 5.60k| case Opcode::I16X8Eq: ------------------ | Branch (235:5): [True: 123, False: 379k] ------------------ 236| 5.64k| case Opcode::I32X4Eq: ------------------ | Branch (236:5): [True: 44, False: 379k] ------------------ 237| 6.82k| case Opcode::F32X4Eq: ------------------ | Branch (237:5): [True: 1.17k, False: 378k] ------------------ 238| 6.82k| case Opcode::F64X2Eq: ------------------ | Branch (238:5): [True: 0, False: 379k] ------------------ 239| 6.82k| case Opcode::I8X16Ne: ------------------ | Branch (239:5): [True: 1, False: 379k] ------------------ 240| 6.82k| case Opcode::I16X8Ne: ------------------ | Branch (240:5): [True: 0, False: 379k] ------------------ 241| 6.87k| case Opcode::I32X4Ne: ------------------ | Branch (241:5): [True: 50, False: 379k] ------------------ 242| 6.87k| case Opcode::F32X4Ne: ------------------ | Branch (242:5): [True: 0, False: 379k] ------------------ 243| 6.87k| case Opcode::F64X2Ne: ------------------ | Branch (243:5): [True: 0, False: 379k] ------------------ 244| 6.87k| case Opcode::I8X16LtS: ------------------ | Branch (244:5): [True: 1, False: 379k] ------------------ 245| 7.09k| case Opcode::I8X16LtU: ------------------ | Branch (245:5): [True: 219, False: 379k] ------------------ 246| 7.14k| case Opcode::I16X8LtS: ------------------ | Branch (246:5): [True: 52, False: 379k] ------------------ 247| 7.49k| case Opcode::I16X8LtU: ------------------ | Branch (247:5): [True: 346, False: 379k] ------------------ 248| 7.93k| case Opcode::I32X4LtS: ------------------ | Branch (248:5): [True: 438, False: 379k] ------------------ 249| 8.32k| case Opcode::I32X4LtU: ------------------ | Branch (249:5): [True: 395, False: 379k] ------------------ 250| 8.32k| case Opcode::F32X4Lt: ------------------ | Branch (250:5): [True: 0, False: 379k] ------------------ 251| 8.45k| case Opcode::F64X2Lt: ------------------ | Branch (251:5): [True: 131, False: 379k] ------------------ 252| 9.64k| case Opcode::I8X16LeS: ------------------ | Branch (252:5): [True: 1.18k, False: 378k] ------------------ 253| 9.64k| case Opcode::I8X16LeU: ------------------ | Branch (253:5): [True: 1, False: 379k] ------------------ 254| 9.76k| case Opcode::I16X8LeS: ------------------ | Branch (254:5): [True: 121, False: 379k] ------------------ 255| 10.7k| case Opcode::I16X8LeU: ------------------ | Branch (255:5): [True: 974, False: 378k] ------------------ 256| 10.7k| case Opcode::I32X4LeS: ------------------ | Branch (256:5): [True: 4, False: 379k] ------------------ 257| 10.7k| case Opcode::I32X4LeU: ------------------ | Branch (257:5): [True: 0, False: 379k] ------------------ 258| 10.7k| case Opcode::F32X4Le: ------------------ | Branch (258:5): [True: 0, False: 379k] ------------------ 259| 10.7k| case Opcode::F64X2Le: ------------------ | Branch (259:5): [True: 21, False: 379k] ------------------ 260| 10.7k| case Opcode::I8X16GtS: ------------------ | Branch (260:5): [True: 0, False: 379k] ------------------ 261| 10.9k| case Opcode::I8X16GtU: ------------------ | Branch (261:5): [True: 147, False: 379k] ------------------ 262| 12.2k| case Opcode::I16X8GtS: ------------------ | Branch (262:5): [True: 1.29k, False: 378k] ------------------ 263| 12.3k| case Opcode::I16X8GtU: ------------------ | Branch (263:5): [True: 195, False: 379k] ------------------ 264| 12.3k| case Opcode::I32X4GtS: ------------------ | Branch (264:5): [True: 1, False: 379k] ------------------ 265| 12.3k| case Opcode::I32X4GtU: ------------------ | Branch (265:5): [True: 0, False: 379k] ------------------ 266| 12.3k| case Opcode::F32X4Gt: ------------------ | Branch (266:5): [True: 0, False: 379k] ------------------ 267| 12.4k| case Opcode::F64X2Gt: ------------------ | Branch (267:5): [True: 1, False: 379k] ------------------ 268| 12.4k| case Opcode::I8X16GeS: ------------------ | Branch (268:5): [True: 0, False: 379k] ------------------ 269| 12.5k| case Opcode::I8X16GeU: ------------------ | Branch (269:5): [True: 160, False: 379k] ------------------ 270| 12.6k| case Opcode::I16X8GeS: ------------------ | Branch (270:5): [True: 63, False: 379k] ------------------ 271| 12.6k| case Opcode::I16X8GeU: ------------------ | Branch (271:5): [True: 55, False: 379k] ------------------ 272| 12.7k| case Opcode::I32X4GeS: ------------------ | Branch (272:5): [True: 81, False: 379k] ------------------ 273| 12.7k| case Opcode::I32X4GeU: ------------------ | Branch (273:5): [True: 20, False: 379k] ------------------ 274| 12.7k| case Opcode::F32X4Ge: ------------------ | Branch (274:5): [True: 0, False: 379k] ------------------ 275| 12.7k| case Opcode::F64X2Ge: ------------------ | Branch (275:5): [True: 0, False: 379k] ------------------ 276| 12.7k| case Opcode::F32X4Neg: ------------------ | Branch (276:5): [True: 1, False: 379k] ------------------ 277| 12.7k| case Opcode::F64X2Neg: ------------------ | Branch (277:5): [True: 0, False: 379k] ------------------ 278| 12.7k| case Opcode::F32X4Abs: ------------------ | Branch (278:5): [True: 2, False: 379k] ------------------ 279| 12.7k| case Opcode::F64X2Abs: ------------------ | Branch (279:5): [True: 1, False: 379k] ------------------ 280| 12.7k| case Opcode::F32X4Min: ------------------ | Branch (280:5): [True: 7, False: 379k] ------------------ 281| 12.9k| case Opcode::F32X4PMin: ------------------ | Branch (281:5): [True: 119, False: 379k] ------------------ 282| 12.9k| case Opcode::F64X2Min: ------------------ | Branch (282:5): [True: 3, False: 379k] ------------------ 283| 12.9k| case Opcode::F64X2PMin: ------------------ | Branch (283:5): [True: 15, False: 379k] ------------------ 284| 12.9k| case Opcode::F32X4Max: ------------------ | Branch (284:5): [True: 2, False: 379k] ------------------ 285| 12.9k| case Opcode::F32X4PMax: ------------------ | Branch (285:5): [True: 0, False: 379k] ------------------ 286| 12.9k| case Opcode::F64X2Max: ------------------ | Branch (286:5): [True: 0, False: 379k] ------------------ 287| 12.9k| case Opcode::F64X2PMax: ------------------ | Branch (287:5): [True: 2, False: 379k] ------------------ 288| 12.9k| case Opcode::F32X4Add: ------------------ | Branch (288:5): [True: 0, False: 379k] ------------------ 289| 12.9k| case Opcode::F64X2Add: ------------------ | Branch (289:5): [True: 0, False: 379k] ------------------ 290| 12.9k| case Opcode::F32X4Sub: ------------------ | Branch (290:5): [True: 0, False: 379k] ------------------ 291| 12.9k| case Opcode::F64X2Sub: ------------------ | Branch (291:5): [True: 0, False: 379k] ------------------ 292| 12.9k| case Opcode::F32X4Div: ------------------ | Branch (292:5): [True: 0, False: 379k] ------------------ 293| 12.9k| case Opcode::F64X2Div: ------------------ | Branch (293:5): [True: 3, False: 379k] ------------------ 294| 12.9k| case Opcode::F32X4Mul: ------------------ | Branch (294:5): [True: 0, False: 379k] ------------------ 295| 12.9k| case Opcode::F64X2Mul: ------------------ | Branch (295:5): [True: 0, False: 379k] ------------------ 296| 12.9k| case Opcode::F32X4Sqrt: ------------------ | Branch (296:5): [True: 0, False: 379k] ------------------ 297| 12.9k| case Opcode::F64X2Sqrt: ------------------ | Branch (297:5): [True: 0, False: 379k] ------------------ 298| 13.6k| case Opcode::F32X4ConvertI32X4S: ------------------ | Branch (298:5): [True: 681, False: 379k] ------------------ 299| 13.6k| case Opcode::F32X4ConvertI32X4U: ------------------ | Branch (299:5): [True: 25, False: 379k] ------------------ 300| 13.6k| case Opcode::I32X4TruncSatF32X4S: ------------------ | Branch (300:5): [True: 30, False: 379k] ------------------ 301| 13.7k| case Opcode::I32X4TruncSatF32X4U: ------------------ | Branch (301:5): [True: 35, False: 379k] ------------------ 302| 13.7k| case Opcode::I8X16Swizzle: ------------------ | Branch (302:5): [True: 0, False: 379k] ------------------ 303| 13.7k| case Opcode::I8X16Shuffle: ------------------ | Branch (303:5): [True: 4, False: 379k] ------------------ 304| 13.7k| case Opcode::V128Load8Splat: ------------------ | Branch (304:5): [True: 27, False: 379k] ------------------ 305| 13.7k| case Opcode::V128Load16Splat: ------------------ | Branch (305:5): [True: 24, False: 379k] ------------------ 306| 14.0k| case Opcode::V128Load32Splat: ------------------ | Branch (306:5): [True: 334, False: 379k] ------------------ 307| 14.1k| case Opcode::V128Load64Splat: ------------------ | Branch (307:5): [True: 11, False: 379k] ------------------ 308| 14.2k| case Opcode::V128Load8Lane: ------------------ | Branch (308:5): [True: 108, False: 379k] ------------------ 309| 14.2k| case Opcode::V128Load16Lane: ------------------ | Branch (309:5): [True: 29, False: 379k] ------------------ 310| 14.2k| case Opcode::V128Load32Lane: ------------------ | Branch (310:5): [True: 33, False: 379k] ------------------ 311| 14.2k| case Opcode::V128Load64Lane: ------------------ | Branch (311:5): [True: 0, False: 379k] ------------------ 312| 14.2k| case Opcode::V128Store8Lane: ------------------ | Branch (312:5): [True: 0, False: 379k] ------------------ 313| 14.4k| case Opcode::V128Store16Lane: ------------------ | Branch (313:5): [True: 176, False: 379k] ------------------ 314| 14.4k| case Opcode::V128Store32Lane: ------------------ | Branch (314:5): [True: 0, False: 379k] ------------------ 315| 14.4k| case Opcode::V128Store64Lane: ------------------ | Branch (315:5): [True: 25, False: 379k] ------------------ 316| 17.7k| case Opcode::I8X16Abs: ------------------ | Branch (316:5): [True: 3.31k, False: 376k] ------------------ 317| 17.7k| case Opcode::I16X8Abs: ------------------ | Branch (317:5): [True: 0, False: 379k] ------------------ 318| 17.7k| case Opcode::I32X4Abs: ------------------ | Branch (318:5): [True: 0, False: 379k] ------------------ 319| 17.7k| return features.simd_enabled(); 320| | 321| 0| case Opcode::I8X16RelaxedSwizzle: ------------------ | Branch (321:5): [True: 0, False: 379k] ------------------ 322| 0| case Opcode::I32X4RelaxedTruncF32X4S: ------------------ | Branch (322:5): [True: 0, False: 379k] ------------------ 323| 0| case Opcode::I32X4RelaxedTruncF32X4U: ------------------ | Branch (323:5): [True: 0, False: 379k] ------------------ 324| 0| case Opcode::I32X4RelaxedTruncF64X2SZero: ------------------ | Branch (324:5): [True: 0, False: 379k] ------------------ 325| 0| case Opcode::I32X4RelaxedTruncF64X2UZero: ------------------ | Branch (325:5): [True: 0, False: 379k] ------------------ 326| 0| case Opcode::F32X4RelaxedMadd: ------------------ | Branch (326:5): [True: 0, False: 379k] ------------------ 327| 0| case Opcode::F32X4RelaxedNmadd: ------------------ | Branch (327:5): [True: 0, False: 379k] ------------------ 328| 0| case Opcode::F64X2RelaxedMadd: ------------------ | Branch (328:5): [True: 0, False: 379k] ------------------ 329| 0| case Opcode::F64X2RelaxedNmadd: ------------------ | Branch (329:5): [True: 0, False: 379k] ------------------ 330| 0| case Opcode::I8X16RelaxedLaneSelect: ------------------ | Branch (330:5): [True: 0, False: 379k] ------------------ 331| 0| case Opcode::I16X8RelaxedLaneSelect: ------------------ | Branch (331:5): [True: 0, False: 379k] ------------------ 332| 0| case Opcode::I32X4RelaxedLaneSelect: ------------------ | Branch (332:5): [True: 0, False: 379k] ------------------ 333| 0| case Opcode::I64X2RelaxedLaneSelect: ------------------ | Branch (333:5): [True: 0, False: 379k] ------------------ 334| 0| case Opcode::F32X4RelaxedMin: ------------------ | Branch (334:5): [True: 0, False: 379k] ------------------ 335| 0| case Opcode::F32X4RelaxedMax: ------------------ | Branch (335:5): [True: 0, False: 379k] ------------------ 336| 0| case Opcode::F64X2RelaxedMin: ------------------ | Branch (336:5): [True: 0, False: 379k] ------------------ 337| 0| case Opcode::F64X2RelaxedMax: ------------------ | Branch (337:5): [True: 0, False: 379k] ------------------ 338| 0| case Opcode::I16X8RelaxedQ15mulrS: ------------------ | Branch (338:5): [True: 0, False: 379k] ------------------ 339| 0| case Opcode::I16X8DotI8X16I7X16S: ------------------ | Branch (339:5): [True: 0, False: 379k] ------------------ 340| 0| case Opcode::I32X4DotI8X16I7X16AddS: ------------------ | Branch (340:5): [True: 0, False: 379k] ------------------ 341| 0| return features.relaxed_simd_enabled(); 342| | 343| 0| case Opcode::MemoryInit: ------------------ | Branch (343:5): [True: 0, False: 379k] ------------------ 344| 1| case Opcode::DataDrop: ------------------ | Branch (344:5): [True: 1, False: 379k] ------------------ 345| 1| case Opcode::MemoryCopy: ------------------ | Branch (345:5): [True: 0, False: 379k] ------------------ 346| 298| case Opcode::MemoryFill: ------------------ | Branch (346:5): [True: 297, False: 379k] ------------------ 347| 298| case Opcode::TableInit: ------------------ | Branch (347:5): [True: 0, False: 379k] ------------------ 348| 298| case Opcode::ElemDrop: ------------------ | Branch (348:5): [True: 0, False: 379k] ------------------ 349| 351| case Opcode::TableCopy: ------------------ | Branch (349:5): [True: 53, False: 379k] ------------------ 350| 351| return features.bulk_memory_enabled(); 351| | 352| 50| case Opcode::TableGet: ------------------ | Branch (352:5): [True: 50, False: 379k] ------------------ 353| 144| case Opcode::TableSet: ------------------ | Branch (353:5): [True: 94, False: 379k] ------------------ 354| 144| case Opcode::TableGrow: ------------------ | Branch (354:5): [True: 0, False: 379k] ------------------ 355| 144| case Opcode::TableSize: ------------------ | Branch (355:5): [True: 0, False: 379k] ------------------ 356| 175| case Opcode::RefNull: ------------------ | Branch (356:5): [True: 31, False: 379k] ------------------ 357| 209| case Opcode::RefIsNull: ------------------ | Branch (357:5): [True: 34, False: 379k] ------------------ 358| 209| return features.reference_types_enabled(); 359| | 360| 107| case Opcode::CallRef: ------------------ | Branch (360:5): [True: 107, False: 379k] ------------------ 361| 107| return features.function_references_enabled(); 362| | 363| | // Interpreter opcodes are never "enabled". 364| 1| case Opcode::InterpAlloca: ------------------ | Branch (364:5): [True: 1, False: 379k] ------------------ 365| 2| case Opcode::InterpBrUnless: ------------------ | Branch (365:5): [True: 1, False: 379k] ------------------ 366| 3| case Opcode::InterpCallImport: ------------------ | Branch (366:5): [True: 1, False: 379k] ------------------ 367| 3| case Opcode::InterpData: ------------------ | Branch (367:5): [True: 0, False: 379k] ------------------ 368| 3| case Opcode::InterpDropKeep: ------------------ | Branch (368:5): [True: 0, False: 379k] ------------------ 369| 3| return false; 370| | 371| 353k| default: ------------------ | Branch (371:5): [True: 353k, False: 26.3k] ------------------ 372| 353k| return true; 373| 379k| } 374| 379k|} _ZNK4wabt6Opcode16GetSimdLaneCountEv: 376| 1.39k|uint32_t Opcode::GetSimdLaneCount() const { 377| 1.39k| switch (enum_) { 378| 4| case Opcode::I8X16ExtractLaneS: ------------------ | Branch (378:5): [True: 4, False: 1.39k] ------------------ 379| 4| case Opcode::I8X16ExtractLaneU: ------------------ | Branch (379:5): [True: 0, False: 1.39k] ------------------ 380| 96| case Opcode::I8X16ReplaceLane: ------------------ | Branch (380:5): [True: 92, False: 1.30k] ------------------ 381| 204| case Opcode::V128Load8Lane: ------------------ | Branch (381:5): [True: 108, False: 1.28k] ------------------ 382| 204| case Opcode::V128Store8Lane: ------------------ | Branch (382:5): [True: 0, False: 1.39k] ------------------ 383| 204| return 16; 384| 0| break; 385| 1| case Opcode::I16X8ExtractLaneS: ------------------ | Branch (385:5): [True: 1, False: 1.39k] ------------------ 386| 182| case Opcode::I16X8ExtractLaneU: ------------------ | Branch (386:5): [True: 181, False: 1.21k] ------------------ 387| 466| case Opcode::I16X8ReplaceLane: ------------------ | Branch (387:5): [True: 284, False: 1.11k] ------------------ 388| 494| case Opcode::V128Load16Lane: ------------------ | Branch (388:5): [True: 28, False: 1.36k] ------------------ 389| 670| case Opcode::V128Store16Lane: ------------------ | Branch (389:5): [True: 176, False: 1.21k] ------------------ 390| 670| return 8; 391| 0| break; 392| 0| case Opcode::F32X4ExtractLane: ------------------ | Branch (392:5): [True: 0, False: 1.39k] ------------------ 393| 5| case Opcode::F32X4ReplaceLane: ------------------ | Branch (393:5): [True: 5, False: 1.39k] ------------------ 394| 5| case Opcode::I32X4ExtractLane: ------------------ | Branch (394:5): [True: 0, False: 1.39k] ------------------ 395| 5| case Opcode::I32X4ReplaceLane: ------------------ | Branch (395:5): [True: 0, False: 1.39k] ------------------ 396| 38| case Opcode::V128Load32Lane: ------------------ | Branch (396:5): [True: 33, False: 1.36k] ------------------ 397| 38| case Opcode::V128Store32Lane: ------------------ | Branch (397:5): [True: 0, False: 1.39k] ------------------ 398| 38| return 4; 399| 0| break; 400| 205| case Opcode::F64X2ExtractLane: ------------------ | Branch (400:5): [True: 205, False: 1.19k] ------------------ 401| 205| case Opcode::F64X2ReplaceLane: ------------------ | Branch (401:5): [True: 0, False: 1.39k] ------------------ 402| 458| case Opcode::I64X2ExtractLane: ------------------ | Branch (402:5): [True: 253, False: 1.14k] ------------------ 403| 458| case Opcode::I64X2ReplaceLane: ------------------ | Branch (403:5): [True: 0, False: 1.39k] ------------------ 404| 458| case Opcode::V128Load64Lane: ------------------ | Branch (404:5): [True: 0, False: 1.39k] ------------------ 405| 483| case Opcode::V128Store64Lane: ------------------ | Branch (405:5): [True: 25, False: 1.37k] ------------------ 406| 483| return 2; 407| 0| break; 408| 0| default: ------------------ | Branch (408:5): [True: 0, False: 1.39k] ------------------ 409| 0| WABT_UNREACHABLE; ------------------ | | 112| 0|#define WABT_UNREACHABLE abort() ------------------ 410| 1.39k| } 411| 1.39k|} _ZNK4wabt6Opcode8GetBytesEv: 414| 100|std::vector Opcode::GetBytes() const { 415| 100| std::vector result; 416| 100| if (HasPrefix()) { ------------------ | Branch (416:7): [True: 20, False: 80] ------------------ 417| 20| result.push_back(GetPrefix()); 418| 20| uint8_t buffer[5]; 419| 20| Offset length = 420| 20| WriteU32Leb128Raw(buffer, buffer + sizeof(buffer), GetCode()); 421| 20| assert(length != 0); 422| 20| result.insert(result.end(), buffer, buffer + length); 423| 80| } else { 424| 80| result.push_back(GetCode()); 425| 80| } 426| 100| return result; 427| 100|} _ZN4wabt15SharedValidator12ToTypeVectorEjPKNS_4TypeE: 25| 3.90k|TypeVector SharedValidator::ToTypeVector(Index count, const Type* types) { 26| 3.90k| return TypeVector(&types[0], &types[count]); 27| 3.90k|} _ZN4wabt15SharedValidatorC2EPNSt3__16vectorINS_5ErrorENS1_9allocatorIS3_EEEERKNS_15ValidateOptionsE: 30| 981| : options_(options), errors_(errors), typechecker_(options.features) { 31| 981| typechecker_.set_error_callback( 32| 981| [this](const char* msg) { OnTypecheckerError(msg); }); 33| 981|} _ZN4wabt15SharedValidator10PrintErrorERKNS_8LocationEPKcz: 37| 440| ...) { 38| 440| WABT_SNPRINTF_ALLOCA(buffer, length, format); ------------------ | | 36| 440| va_list args; \ | | 37| 440| va_list args_copy; \ | | 38| 440| va_start(args, format); \ | | 39| 440| va_copy(args_copy, args); \ | | 40| 440| char fixed_buf[WABT_DEFAULT_SNPRINTF_ALLOCA_BUFSIZE]; \ | | 41| 440| char* buffer = fixed_buf; \ | | 42| 440| size_t len = wabt_vsnprintf(fixed_buf, sizeof(fixed_buf), format, args); \ | | ------------------ | | | | 301| 440|#define wabt_vsnprintf vsnprintf | | ------------------ | | 43| 440| va_end(args); \ | | 44| 440| if (len + 1 > sizeof(fixed_buf)) { \ | | ------------------ | | | Branch (44:7): [True: 0, False: 440] | | ------------------ | | 45| 0| buffer = static_cast(alloca(len + 1)); \ | | 46| 0| len = wabt_vsnprintf(buffer, len + 1, format, args_copy); \ | | ------------------ | | | | 301| 0|#define wabt_vsnprintf vsnprintf | | ------------------ | | 47| 0| } \ | | 48| 440| va_end(args_copy) ------------------ 39| 440| errors_->emplace_back(ErrorLevel::Error, loc, buffer); 40| 440| return Result::Error; 41| 440|} _ZN4wabt15SharedValidator18OnTypecheckerErrorEPKc: 43| 207|void SharedValidator::OnTypecheckerError(const char* msg) { 44| 207| PrintError(expr_loc_, "%s", msg); 45| 207|} _ZN4wabt15SharedValidator10OnFuncTypeERKNS_8LocationEjPKNS_4TypeEjS6_j: 52| 1.47k| Index type_index) { 53| 1.47k| Result result = Result::Ok; 54| 1.47k| if (!options_.features.multi_value_enabled() && result_count > 1) { ------------------ | Branch (54:7): [True: 0, False: 1.47k] | Branch (54:51): [True: 0, False: 0] ------------------ 55| 0| result |= PrintError(loc, 56| 0| "multiple result values are not supported without " 57| 0| "multi-value enabled."); 58| 0| } 59| 1.47k| func_types_.emplace( 60| 1.47k| num_types_++, 61| 1.47k| FuncType{ToTypeVector(param_count, param_types), 62| 1.47k| ToTypeVector(result_count, result_types), type_index}); 63| 1.47k| return result; 64| 1.47k|} _ZN4wabt15SharedValidator10OnFunctionERKNS_8LocationENS_3VarE: 79| 9.08k|Result SharedValidator::OnFunction(const Location& loc, Var sig_var) { 80| 9.08k| Result result = Result::Ok; 81| 9.08k| FuncType type; 82| 9.08k| result |= CheckFuncTypeIndex(sig_var, &type); 83| 9.08k| funcs_.push_back(type); 84| 9.08k| return result; 85| 9.08k|} _ZN4wabt15SharedValidator11CheckLimitsERKNS_8LocationERKNS_6LimitsEmPKc: 90| 489| const char* desc) { 91| 489| Result result = Result::Ok; 92| 489| if (limits.initial > absolute_max) { ------------------ | Branch (92:7): [True: 0, False: 489] ------------------ 93| 0| result |= 94| 0| PrintError(loc, "initial %s (%" PRIu64 ") must be <= (%" PRIu64 ")", 95| 0| desc, limits.initial, absolute_max); 96| 0| } 97| | 98| 489| if (limits.has_max) { ------------------ | Branch (98:7): [True: 210, False: 279] ------------------ 99| 210| if (limits.max > absolute_max) { ------------------ | Branch (99:9): [True: 0, False: 210] ------------------ 100| 0| result |= PrintError(loc, "max %s (%" PRIu64 ") must be <= (%" PRIu64 ")", 101| 0| desc, limits.max, absolute_max); 102| 0| } 103| | 104| 210| if (limits.max < limits.initial) { ------------------ | Branch (104:9): [True: 2, False: 208] ------------------ 105| 2| result |= PrintError( 106| 2| loc, "max %s (%" PRIu64 ") must be >= initial %s (%" PRIu64 ")", desc, 107| 2| limits.max, desc, limits.initial); 108| 2| } 109| 210| } 110| 489| return result; 111| 489|} _ZN4wabt15SharedValidator7OnTableERKNS_8LocationENS_4TypeERKNS_6LimitsE: 115| 146| const Limits& limits) { 116| 146| Result result = Result::Ok; 117| 146| if (tables_.size() > 0 && !options_.features.reference_types_enabled()) { ------------------ | Branch (117:7): [True: 9, False: 137] | Branch (117:29): [True: 0, False: 9] ------------------ 118| 0| result |= PrintError(loc, "only one table allowed"); 119| 0| } 120| 146| result |= CheckLimits(loc, limits, UINT32_MAX, "elems"); 121| | 122| 146| if (limits.is_shared) { ------------------ | Branch (122:7): [True: 0, False: 146] ------------------ 123| 0| result |= PrintError(loc, "tables may not be shared"); 124| 0| } 125| 146| if (elem_type != Type::FuncRef && ------------------ | Branch (125:7): [True: 42, False: 104] ------------------ 126| 146| !options_.features.reference_types_enabled()) { ------------------ | Branch (126:7): [True: 0, False: 42] ------------------ 127| 0| result |= PrintError(loc, "tables must have funcref type"); 128| 0| } 129| 146| if (!elem_type.IsRef()) { ------------------ | Branch (129:7): [True: 0, False: 146] ------------------ 130| 0| result |= PrintError(loc, "tables must have reference types"); 131| 0| } 132| | 133| 146| tables_.push_back(TableType{elem_type, limits}); 134| 146| return result; 135| 146|} _ZN4wabt15SharedValidator8OnMemoryERKNS_8LocationERKNS_6LimitsE: 137| 343|Result SharedValidator::OnMemory(const Location& loc, const Limits& limits) { 138| 343| Result result = Result::Ok; 139| 343| if (memories_.size() > 0 && !options_.features.multi_memory_enabled()) { ------------------ | Branch (139:7): [True: 81, False: 262] | Branch (139:31): [True: 1, False: 80] ------------------ 140| 1| result |= PrintError(loc, "only one memory block allowed"); 141| 1| } 142| 343| result |= CheckLimits( 143| 343| loc, limits, limits.is_64 ? WABT_MAX_PAGES64 : WABT_MAX_PAGES32, "pages"); ------------------ | | 51| 36|#define WABT_MAX_PAGES64 0x1000000000000 ------------------ loc, limits, limits.is_64 ? WABT_MAX_PAGES64 : WABT_MAX_PAGES32, "pages"); ------------------ | | 49| 650|#define WABT_MAX_PAGES32 0x10000 ------------------ | Branch (143:20): [True: 36, False: 307] ------------------ 144| | 145| 343| if (limits.is_shared) { ------------------ | Branch (145:7): [True: 2, False: 341] ------------------ 146| 2| if (!options_.features.threads_enabled()) { ------------------ | Branch (146:9): [True: 0, False: 2] ------------------ 147| 0| result |= PrintError(loc, "memories may not be shared"); 148| 2| } else if (!limits.has_max) { ------------------ | Branch (148:16): [True: 0, False: 2] ------------------ 149| 0| result |= PrintError(loc, "shared memories must have max sizes"); 150| 0| } 151| 2| } 152| | 153| 343| memories_.push_back(MemoryType{limits}); 154| 343| return result; 155| 343|} _ZN4wabt15SharedValidator14OnGlobalImportERKNS_8LocationENS_4TypeEb: 159| 20| bool mutable_) { 160| 20| Result result = Result::Ok; 161| 20| if (mutable_ && !options_.features.mutable_globals_enabled()) { ------------------ | Branch (161:7): [True: 0, False: 20] | Branch (161:19): [True: 0, False: 0] ------------------ 162| 0| result |= PrintError(loc, "mutable globals cannot be imported"); 163| 0| } 164| 20| globals_.push_back(GlobalType{type, mutable_}); 165| 20| ++num_imported_globals_; 166| 20| return result; 167| 20|} _ZN4wabt15SharedValidator8OnGlobalERKNS_8LocationENS_4TypeEb: 171| 222| bool mutable_) { 172| 222| globals_.push_back(GlobalType{type, mutable_}); 173| 222| return Result::Ok; 174| 222|} _ZN4wabt15SharedValidator9CheckTypeERKNS_8LocationENS_4TypeES4_PKc: 179| 68| const char* desc) { 180| 68| if (Failed(TypeChecker::CheckType(actual, expected))) { ------------------ | Branch (180:7): [True: 0, False: 68] ------------------ 181| 0| PrintError(loc, "type mismatch at %s. got %s, expected %s", desc, 182| 0| actual.GetName().c_str(), expected.GetName().c_str()); 183| 0| return Result::Error; 184| 0| } 185| 68| return Result::Ok; 186| 68|} _ZN4wabt15SharedValidator5OnTagERKNS_8LocationENS_3VarE: 188| 7|Result SharedValidator::OnTag(const Location& loc, Var sig_var) { 189| 7| Result result = Result::Ok; 190| 7| FuncType type; 191| 7| result |= CheckFuncTypeIndex(sig_var, &type); 192| 7| if (!type.results.empty()) { ------------------ | Branch (192:7): [True: 0, False: 7] ------------------ 193| 0| result |= PrintError(loc, "Tag signature must have 0 results."); 194| 0| } 195| 7| tags_.push_back(TagType{type.params}); 196| 7| return result; 197| 7|} _ZN4wabt15SharedValidator8OnExportERKNS_8LocationENS_12ExternalKindENS_3VarENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE: 202| 2.03k| std::string_view name) { 203| 2.03k| Result result = Result::Ok; 204| 2.03k| auto name_str = std::string(name); 205| 2.03k| if (export_names_.find(name_str) != export_names_.end()) { ------------------ | Branch (205:7): [True: 8, False: 2.03k] ------------------ 206| 8| result |= PrintError(loc, "duplicate export \"" PRIstringview "\"", 207| 8| WABT_PRINTF_STRING_VIEW_ARG(name)); ------------------ | | 28| 8| static_cast((x).length()), (x).data() ------------------ 208| 8| } 209| 2.03k| export_names_.insert(name_str); 210| | 211| 2.03k| switch (kind) { ------------------ | Branch (211:11): [True: 0, False: 2.03k] ------------------ 212| 2.02k| case ExternalKind::Func: ------------------ | Branch (212:5): [True: 2.02k, False: 13] ------------------ 213| 2.02k| result |= CheckFuncIndex(item_var); 214| 2.02k| declared_funcs_.insert(item_var.index()); 215| 2.02k| break; 216| | 217| 2| case ExternalKind::Table: ------------------ | Branch (217:5): [True: 2, False: 2.03k] ------------------ 218| 2| result |= CheckTableIndex(item_var); 219| 2| break; 220| | 221| 5| case ExternalKind::Memory: ------------------ | Branch (221:5): [True: 5, False: 2.03k] ------------------ 222| 5| result |= CheckMemoryIndex(item_var); 223| 5| break; 224| | 225| 5| case ExternalKind::Global: ------------------ | Branch (225:5): [True: 5, False: 2.03k] ------------------ 226| 5| result |= CheckGlobalIndex(item_var); 227| 5| break; 228| | 229| 1| case ExternalKind::Tag: ------------------ | Branch (229:5): [True: 1, False: 2.03k] ------------------ 230| 1| result |= CheckTagIndex(item_var); 231| 1| break; 232| 2.03k| } 233| 2.03k| return result; 234| 2.03k|} _ZN4wabt15SharedValidator7OnStartERKNS_8LocationENS_3VarE: 236| 9|Result SharedValidator::OnStart(const Location& loc, Var func_var) { 237| 9| Result result = Result::Ok; 238| 9| if (starts_++ > 0) { ------------------ | Branch (238:7): [True: 0, False: 9] ------------------ 239| 0| result |= PrintError(loc, "only one start function allowed"); 240| 0| } 241| 9| FuncType func_type; 242| 9| result |= CheckFuncIndex(func_var, &func_type); 243| 9| if (func_type.params.size() != 0) { ------------------ | Branch (243:7): [True: 0, False: 9] ------------------ 244| 0| result |= PrintError(loc, "start function must be nullary"); 245| 0| } 246| 9| if (func_type.results.size() != 0) { ------------------ | Branch (246:7): [True: 0, False: 9] ------------------ 247| 0| result |= PrintError(loc, "start function must not return anything"); 248| 0| } 249| 9| return result; 250| 9|} _ZN4wabt15SharedValidator13OnElemSegmentERKNS_8LocationENS_3VarENS_11SegmentKindE: 254| 22| SegmentKind kind) { 255| 22| Result result = Result::Ok; 256| 22| TableType table_type; 257| 22| if (kind == SegmentKind::Active) { ------------------ | Branch (257:7): [True: 20, False: 2] ------------------ 258| 20| result |= CheckTableIndex(table_var, &table_type); 259| 20| } 260| | // Type gets set later in OnElemSegmentElemType. 261| 22| elems_.push_back( 262| 22| ElemType{Type::Void, kind == SegmentKind::Active, table_type.element}); 263| 22| return result; 264| 22|} _ZN4wabt15SharedValidator21OnElemSegmentElemTypeERKNS_8LocationENS_4TypeE: 267| 17| Type elem_type) { 268| 17| Result result = Result::Ok; 269| 17| auto& elem = elems_.back(); 270| 17| if (elem.is_active) { ------------------ | Branch (270:7): [True: 15, False: 2] ------------------ 271| | // Check that the type of the elem segment matches the table in which 272| | // it is active. 273| 15| result |= CheckType(loc, elem.table_type, elem_type, "elem segment"); 274| 15| } 275| 17| elem.element = elem_type; 276| 17| return result; 277| 17|} _ZN4wabt15SharedValidator11OnDataCountEj: 279| 2|void SharedValidator::OnDataCount(Index count) { 280| 2| data_segments_ = count; 281| 2|} _ZN4wabt15SharedValidator13OnDataSegmentERKNS_8LocationENS_3VarENS_11SegmentKindE: 285| 22| SegmentKind kind) { 286| 22| Result result = Result::Ok; 287| 22| if (kind == SegmentKind::Active) { ------------------ | Branch (287:7): [True: 6, False: 16] ------------------ 288| 6| result |= CheckMemoryIndex(memory_var); 289| 6| } 290| 22| return result; 291| 22|} _ZN4wabt15SharedValidator9EndModuleEv: 303| 34|Result SharedValidator::EndModule() { 304| | // Verify that any ref.func used in init expressions for globals are 305| | // mentioned in an elems section. This can't be done while process the 306| | // globals because the global section comes before the elem section. 307| 34| Result result = Result::Ok; 308| 34| for (Var func_var : check_declared_funcs_) { ------------------ | Branch (308:21): [True: 0, False: 34] ------------------ 309| 0| result |= CheckDeclaredFunc(func_var); 310| 0| } 311| 34| return result; 312| 34|} _ZN4wabt15SharedValidator10CheckIndexENS_3VarEjPKc: 314| 21.7k|Result SharedValidator::CheckIndex(Var var, Index max_index, const char* desc) { 315| 21.7k| if (var.index() >= max_index) { ------------------ | Branch (315:7): [True: 163, False: 21.6k] ------------------ 316| 163| return PrintError( 317| 163| var.loc, "%s variable out of range: %" PRIindex " (max %" PRIindex ")", 318| 163| desc, var.index(), max_index); 319| 163| } 320| 21.6k| return Result::Ok; 321| 21.7k|} _ZN4wabt15SharedValidator15CheckLocalIndexENS_3VarEPNS_4TypeE: 335| 2.71k|Result SharedValidator::CheckLocalIndex(Var local_var, Type* out_type) { 336| 2.71k| auto iter = std::upper_bound( 337| 2.71k| locals_.begin(), locals_.end(), local_var.index(), 338| 2.71k| [](Index index, const LocalDecl& decl) { return index < decl.end; }); 339| 2.71k| if (iter == locals_.end()) { ------------------ | Branch (339:7): [True: 9, False: 2.70k] ------------------ 340| | // TODO: better error 341| 9| return PrintError(local_var.loc, "local variable out of range (max %u)", 342| 9| GetLocalCount()); 343| 9| } 344| 2.70k| *out_type = iter->type; 345| 2.70k| return Result::Ok; 346| 2.71k|} _ZN4wabt15SharedValidator18CheckFuncTypeIndexENS_3VarEPNS0_8FuncTypeE: 348| 11.6k|Result SharedValidator::CheckFuncTypeIndex(Var sig_var, FuncType* out) { 349| 11.6k| Result result = CheckIndex(sig_var, num_types_, "function type"); 350| 11.6k| if (Failed(result)) { ------------------ | Branch (350:7): [True: 78, False: 11.6k] ------------------ 351| 78| *out = FuncType{}; 352| 78| return Result::Error; 353| 78| } 354| | 355| 11.6k| auto iter = func_types_.find(sig_var.index()); 356| 11.6k| if (iter == func_types_.end()) { ------------------ | Branch (356:7): [True: 0, False: 11.6k] ------------------ 357| 0| return PrintError(sig_var.loc, "type %d is not a function", 358| 0| sig_var.index()); 359| 0| } 360| | 361| 11.6k| if (out) { ------------------ | Branch (361:7): [True: 11.6k, False: 0] ------------------ 362| 11.6k| *out = iter->second; 363| 11.6k| } 364| 11.6k| return Result::Ok; 365| 11.6k|} _ZN4wabt15SharedValidator14CheckFuncIndexENS_3VarEPNS0_8FuncTypeE: 367| 2.77k|Result SharedValidator::CheckFuncIndex(Var func_var, FuncType* out) { 368| 2.77k| return CheckIndexWithValue(func_var, funcs_, out, "function"); 369| 2.77k|} _ZN4wabt15SharedValidator16CheckMemoryIndexENS_3VarEPNS0_10MemoryTypeE: 371| 6.15k|Result SharedValidator::CheckMemoryIndex(Var memory_var, MemoryType* out) { 372| 6.15k| return CheckIndexWithValue(memory_var, memories_, out, "memory"); 373| 6.15k|} _ZN4wabt15SharedValidator15CheckTableIndexENS_3VarEPNS0_9TableTypeE: 375| 897|Result SharedValidator::CheckTableIndex(Var table_var, TableType* out) { 376| 897| return CheckIndexWithValue(table_var, tables_, out, "table"); 377| 897|} _ZN4wabt15SharedValidator16CheckGlobalIndexENS_3VarEPNS0_10GlobalTypeE: 379| 235|Result SharedValidator::CheckGlobalIndex(Var global_var, GlobalType* out) { 380| 235| return CheckIndexWithValue(global_var, globals_, out, "global"); 381| 235|} _ZN4wabt15SharedValidator13CheckTagIndexENS_3VarEPNS0_7TagTypeE: 383| 6|Result SharedValidator::CheckTagIndex(Var tag_var, TagType* out) { 384| 6| return CheckIndexWithValue(tag_var, tags_, out, "tag"); 385| 6|} _ZN4wabt15SharedValidator21CheckDataSegmentIndexENS_3VarE: 392| 1|Result SharedValidator::CheckDataSegmentIndex(Var data_segment_var) { 393| 1| return CheckIndex(data_segment_var, data_segments_, "data_segment"); 394| 1|} _ZN4wabt15SharedValidator19CheckBlockSignatureERKNS_8LocationENS_6OpcodeENS_4TypeEPNSt3__16vectorIS5_NS6_9allocatorIS5_EEEESB_: 400| 3.00k| TypeVector* out_result_types) { 401| 3.00k| Result result = Result::Ok; 402| | 403| 3.00k| if (sig_type.IsIndex()) { ------------------ | Branch (403:7): [True: 2.05k, False: 954] ------------------ 404| 2.05k| Index sig_index = sig_type.GetIndex(); 405| 2.05k| FuncType func_type; 406| 2.05k| result |= CheckFuncTypeIndex(Var(sig_index, loc), &func_type); 407| | 408| 2.05k| if (!func_type.params.empty() && !options_.features.multi_value_enabled()) { ------------------ | Branch (408:9): [True: 91, False: 1.95k] | Branch (408:38): [True: 0, False: 91] ------------------ 409| 0| result |= PrintError(loc, "%s params not currently supported.", 410| 0| opcode.GetName()); 411| 0| } 412| | // Multiple results without --enable-multi-value is checked above in 413| | // OnType. 414| | 415| 2.05k| *out_param_types = func_type.params; 416| 2.05k| *out_result_types = func_type.results; 417| 2.05k| } else { 418| 954| out_param_types->clear(); 419| 954| *out_result_types = sig_type.GetInlineVector(); 420| 954| } 421| | 422| 3.00k| return result; 423| 3.00k|} _ZNK4wabt15SharedValidator20GetFunctionTypeIndexEj: 425| 89|Index SharedValidator::GetFunctionTypeIndex(Index func_index) const { 426| 89| assert(func_index < funcs_.size()); 427| 89| return funcs_[func_index].type_index; 428| 89|} _ZN4wabt15SharedValidator13BeginInitExprERKNS_8LocationENS_4TypeE: 430| 320|Result SharedValidator::BeginInitExpr(const Location& loc, Type type) { 431| 320| expr_loc_ = loc; 432| 320| in_init_expr_ = true; 433| 320| return typechecker_.BeginInitExpr(type); 434| 320|} _ZN4wabt15SharedValidator11EndInitExprEv: 436| 281|Result SharedValidator::EndInitExpr() { 437| 281| in_init_expr_ = false; 438| 281| return typechecker_.EndInitExpr(); 439| 281|} _ZN4wabt15SharedValidator17BeginFunctionBodyERKNS_8LocationEj: 442| 2.23k| Index func_index) { 443| 2.23k| expr_loc_ = loc; 444| 2.23k| locals_.clear(); 445| 2.23k| if (func_index < funcs_.size()) { ------------------ | Branch (445:7): [True: 2.23k, False: 0] ------------------ 446| 2.23k| for (Type type : funcs_[func_index].params) { ------------------ | Branch (446:20): [True: 1.90k, False: 2.23k] ------------------ 447| | // TODO: Coalesce parameters of the same type? 448| 1.90k| locals_.push_back(LocalDecl{type, GetLocalCount() + 1}); 449| 1.90k| } 450| 2.23k| return typechecker_.BeginFunction(funcs_[func_index].results); 451| 2.23k| } else { 452| | // Signature isn't available, use empty. 453| 0| return typechecker_.BeginFunction(TypeVector()); 454| 0| } 455| 2.23k|} _ZN4wabt15SharedValidator15EndFunctionBodyERKNS_8LocationE: 457| 1.85k|Result SharedValidator::EndFunctionBody(const Location& loc) { 458| 1.85k| expr_loc_ = loc; 459| 1.85k| return typechecker_.EndFunction(); 460| 1.85k|} _ZN4wabt15SharedValidator11OnLocalDeclERKNS_8LocationEjNS_4TypeE: 464| 93| Type type) { 465| 93| const auto max_locals = std::numeric_limits::max(); 466| 93| if (count > max_locals - GetLocalCount()) { ------------------ | Branch (466:7): [True: 0, False: 93] ------------------ 467| 0| PrintError(loc, "local count must be < 0x10000000"); 468| 0| return Result::Error; 469| 0| } 470| 93| locals_.push_back(LocalDecl{type, GetLocalCount() + count}); 471| 93| return Result::Ok; 472| 93|} _ZNK4wabt15SharedValidator13GetLocalCountEv: 474| 8.51k|Index SharedValidator::GetLocalCount() const { 475| 8.51k| return locals_.empty() ? 0 : locals_.back().end; ------------------ | Branch (475:10): [True: 3.83k, False: 4.67k] ------------------ 476| 8.51k|} _ZN4wabt15SharedValidator10CheckAlignERKNS_8LocationEmm: 484| 5.73k| Address natural_alignment) { 485| 5.73k| if (!is_power_of_two(alignment)) { ------------------ | Branch (485:7): [True: 6, False: 5.72k] ------------------ 486| 6| PrintError(loc, "alignment (%" PRIaddress ") must be a power of 2", 487| 6| alignment); 488| 6| return Result::Error; 489| 6| } 490| 5.72k| if (alignment > natural_alignment) { ------------------ | Branch (490:7): [True: 17, False: 5.70k] ------------------ 491| 17| PrintError( 492| 17| loc, 493| 17| "alignment must not be larger than natural alignment (%" PRIaddress ")", 494| 17| natural_alignment); 495| 17| return Result::Error; 496| 17| } 497| 5.70k| return Result::Ok; 498| 5.72k|} _ZN4wabt15SharedValidator11CheckOffsetERKNS_8LocationEmRKNS_6LimitsE: 502| 5.74k| const Limits& limits) { 503| 5.74k| if ((!limits.is_64) && (offset > UINT32_MAX)) { ------------------ | Branch (503:7): [True: 5.73k, False: 13] | Branch (503:26): [True: 1, False: 5.73k] ------------------ 504| 1| PrintError(loc, "offset must be less than or equal to 0xffffffff"); 505| 1| return Result::Error; 506| 1| } 507| | 508| 5.74k| return Result::Ok; 509| 5.74k|} _ZN4wabt15SharedValidator16CheckAtomicAlignERKNS_8LocationEmm: 513| 17| Address natural_alignment) { 514| 17| if (!is_power_of_two(alignment)) { ------------------ | Branch (514:7): [True: 0, False: 17] ------------------ 515| 0| PrintError(loc, "alignment (%" PRIaddress ") must be a power of 2", 516| 0| alignment); 517| 0| return Result::Error; 518| 0| } 519| 17| if (alignment != natural_alignment) { ------------------ | Branch (519:7): [True: 1, False: 16] ------------------ 520| 1| PrintError(loc, 521| 1| "alignment must be equal to natural alignment (%" PRIaddress ")", 522| 1| natural_alignment); 523| 1| return Result::Error; 524| 1| } 525| 16| return Result::Ok; 526| 17|} _ZNK4wabt15SharedValidator15ValidInitOpcodeENS_6OpcodeE: 528| 198|bool SharedValidator::ValidInitOpcode(Opcode opcode) const { 529| 198| if (opcode == Opcode::GlobalGet || opcode == Opcode::I32Const || ------------------ | Branch (529:7): [True: 33, False: 165] | Branch (529:38): [True: 0, False: 165] ------------------ 530| 198| opcode == Opcode::I64Const || opcode == Opcode::F32Const || ------------------ | Branch (530:7): [True: 0, False: 165] | Branch (530:37): [True: 0, False: 165] ------------------ 531| 198| opcode == Opcode::F64Const || opcode == Opcode::RefFunc || ------------------ | Branch (531:7): [True: 0, False: 165] | Branch (531:37): [True: 82, False: 83] ------------------ 532| 198| opcode == Opcode::RefNull) { ------------------ | Branch (532:7): [True: 22, False: 61] ------------------ 533| 137| return true; 534| 137| } 535| 61| if (options_.features.extended_const_enabled()) { ------------------ | Branch (535:7): [True: 52, False: 9] ------------------ 536| 52| if (opcode == Opcode::I32Mul || opcode == Opcode::I64Mul || ------------------ | Branch (536:9): [True: 5, False: 47] | Branch (536:37): [True: 5, False: 42] ------------------ 537| 52| opcode == Opcode::I32Sub || opcode == Opcode::I64Sub || ------------------ | Branch (537:9): [True: 5, False: 37] | Branch (537:37): [True: 5, False: 32] ------------------ 538| 52| opcode == Opcode::I32Add || opcode == Opcode::I64Add) { ------------------ | Branch (538:9): [True: 10, False: 22] | Branch (538:37): [True: 10, False: 12] ------------------ 539| 40| return true; 540| 40| } 541| 52| } 542| 21| return false; 543| 61|} _ZN4wabt15SharedValidator10CheckInstrENS_6OpcodeERKNS_8LocationE: 545| 352k|Result SharedValidator::CheckInstr(Opcode opcode, const Location& loc) { 546| 352k| expr_loc_ = loc; 547| 352k| if (in_init_expr_ && !ValidInitOpcode(opcode)) { ------------------ | Branch (547:7): [True: 198, False: 351k] | Branch (547:24): [True: 21, False: 177] ------------------ 548| 21| PrintError(loc, 549| 21| "invalid initializer: instruction not valid in initializer " 550| 21| "expression: %s", 551| 21| opcode.GetName()); 552| 21| return Result::Error; 553| 21| } 554| 352k| return Result::Ok; 555| 352k|} _ZN4wabt15SharedValidator13OnAtomicFenceERKNS_8LocationEj: 558| 234| uint32_t consistency_model) { 559| 234| Result result = CheckInstr(Opcode::AtomicFence, loc); 560| 234| if (consistency_model != 0) { ------------------ | Branch (560:7): [True: 0, False: 234] ------------------ 561| 0| result |= PrintError( 562| 0| loc, "unexpected atomic.fence consistency model (expected 0): %u", 563| 0| consistency_model); 564| 0| } 565| 234| result |= typechecker_.OnAtomicFence(consistency_model); 566| 234| return result; 567| 234|} _ZN4wabt15SharedValidator14OnAtomicNotifyERKNS_8LocationENS_6OpcodeENS_3VarEmm: 587| 1| Address offset) { 588| 1| Result result = CheckInstr(opcode, loc); 589| 1| MemoryType mt; 590| 1| result |= CheckMemoryIndex(memidx, &mt); 591| 1| result |= CheckAtomicAlign(loc, alignment, opcode.GetMemorySize()); 592| 1| result |= CheckOffset(loc, offset, mt.limits); 593| 1| result |= typechecker_.OnAtomicNotify(opcode, mt.limits); 594| 1| return result; 595| 1|} _ZN4wabt15SharedValidator11OnAtomicRmwERKNS_8LocationENS_6OpcodeENS_3VarEmm: 615| 15| Address offset) { 616| 15| Result result = CheckInstr(opcode, loc); 617| 15| MemoryType mt; 618| 15| result |= CheckMemoryIndex(memidx, &mt); 619| 15| result |= CheckAtomicAlign(loc, alignment, opcode.GetMemorySize()); 620| 15| result |= CheckOffset(loc, offset, mt.limits); 621| 15| result |= typechecker_.OnAtomicRmw(opcode, mt.limits); 622| 15| return result; 623| 15|} _ZN4wabt15SharedValidator13OnAtomicStoreERKNS_8LocationENS_6OpcodeENS_3VarEmm: 629| 1| Address offset) { 630| 1| Result result = CheckInstr(opcode, loc); 631| 1| MemoryType mt; 632| 1| result |= CheckMemoryIndex(memidx, &mt); 633| 1| result |= CheckAtomicAlign(loc, alignment, opcode.GetMemorySize()); 634| 1| result |= CheckOffset(loc, offset, mt.limits); 635| 1| result |= typechecker_.OnAtomicStore(opcode, mt.limits); 636| 1| return result; 637| 1|} _ZN4wabt15SharedValidator8OnBinaryERKNS_8LocationENS_6OpcodeE: 653| 43.9k|Result SharedValidator::OnBinary(const Location& loc, Opcode opcode) { 654| 43.9k| Result result = CheckInstr(opcode, loc); 655| 43.9k| result |= typechecker_.OnBinary(opcode); 656| 43.9k| return result; 657| 43.9k|} _ZN4wabt15SharedValidator7OnBlockERKNS_8LocationENS_4TypeE: 659| 1.84k|Result SharedValidator::OnBlock(const Location& loc, Type sig_type) { 660| 1.84k| Result result = CheckInstr(Opcode::Block, loc); 661| 1.84k| TypeVector param_types, result_types; 662| 1.84k| result |= CheckBlockSignature(loc, Opcode::Block, sig_type, ¶m_types, 663| 1.84k| &result_types); 664| 1.84k| result |= typechecker_.OnBlock(param_types, result_types); 665| 1.84k| return result; 666| 1.84k|} _ZN4wabt15SharedValidator4OnBrERKNS_8LocationENS_3VarE: 668| 476|Result SharedValidator::OnBr(const Location& loc, Var depth) { 669| 476| Result result = CheckInstr(Opcode::Br, loc); 670| 476| result |= typechecker_.OnBr(depth.index()); 671| 476| return result; 672| 476|} _ZN4wabt15SharedValidator6OnBrIfERKNS_8LocationENS_3VarE: 674| 48|Result SharedValidator::OnBrIf(const Location& loc, Var depth) { 675| 48| Result result = CheckInstr(Opcode::BrIf, loc); 676| 48| result |= typechecker_.OnBrIf(depth.index()); 677| 48| return result; 678| 48|} _ZN4wabt15SharedValidator12BeginBrTableERKNS_8LocationE: 680| 1.35k|Result SharedValidator::BeginBrTable(const Location& loc) { 681| 1.35k| Result result = CheckInstr(Opcode::BrTable, loc); 682| 1.35k| result |= typechecker_.BeginBrTable(); 683| 1.35k| return result; 684| 1.35k|} _ZN4wabt15SharedValidator15OnBrTableTargetERKNS_8LocationENS_3VarE: 686| 3.50k|Result SharedValidator::OnBrTableTarget(const Location& loc, Var depth) { 687| 3.50k| Result result = Result::Ok; 688| 3.50k| expr_loc_ = loc; 689| 3.50k| result |= typechecker_.OnBrTableTarget(depth.index()); 690| 3.50k| return result; 691| 3.50k|} _ZN4wabt15SharedValidator10EndBrTableERKNS_8LocationE: 693| 1.34k|Result SharedValidator::EndBrTable(const Location& loc) { 694| 1.34k| Result result = CheckInstr(Opcode::BrTable, loc); 695| 1.34k| result |= typechecker_.EndBrTable(); 696| 1.34k| return result; 697| 1.34k|} _ZN4wabt15SharedValidator6OnCallERKNS_8LocationENS_3VarE: 699| 643|Result SharedValidator::OnCall(const Location& loc, Var func_var) { 700| 643| Result result = CheckInstr(Opcode::Call, loc); 701| 643| FuncType func_type; 702| 643| result |= CheckFuncIndex(func_var, &func_type); 703| 643| result |= typechecker_.OnCall(func_type.params, func_type.results); 704| 643| return result; 705| 643|} _ZN4wabt15SharedValidator14OnCallIndirectERKNS_8LocationENS_3VarES4_: 709| 338| Var table_var) { 710| 338| Result result = CheckInstr(Opcode::CallIndirect, loc); 711| 338| FuncType func_type; 712| 338| TableType table_type; 713| 338| result |= CheckFuncTypeIndex(sig_var, &func_type); 714| 338| result |= CheckTableIndex(table_var, &table_type); 715| 338| result |= typechecker_.OnCallIndirect(func_type.params, func_type.results, 716| 338| table_type.limits); 717| 338| return result; 718| 338|} _ZN4wabt15SharedValidator7OnCatchERKNS_8LocationENS_3VarEb: 739| 4| bool is_catch_all) { 740| 4| Result result = CheckInstr(Opcode::Catch, loc); 741| 4| if (is_catch_all) { ------------------ | Branch (741:7): [True: 0, False: 4] ------------------ 742| 0| TypeVector empty; 743| 0| result |= typechecker_.OnCatch(empty); 744| 4| } else { 745| 4| TagType tag_type; 746| 4| result |= CheckTagIndex(tag_var, &tag_type); 747| 4| result |= typechecker_.OnCatch(tag_type.params); 748| 4| } 749| 4| return result; 750| 4|} _ZN4wabt15SharedValidator9OnCompareERKNS_8LocationENS_6OpcodeE: 752| 12.0k|Result SharedValidator::OnCompare(const Location& loc, Opcode opcode) { 753| 12.0k| Result result = CheckInstr(opcode, loc); 754| 12.0k| result |= typechecker_.OnCompare(opcode); 755| 12.0k| return result; 756| 12.0k|} _ZN4wabt15SharedValidator7OnConstERKNS_8LocationENS_4TypeE: 758| 26.6k|Result SharedValidator::OnConst(const Location& loc, Type type) { 759| 26.6k| Result result = Result::Ok; 760| 26.6k| expr_loc_ = loc; 761| 26.6k| result |= typechecker_.OnConst(type); 762| 26.6k| return result; 763| 26.6k|} _ZN4wabt15SharedValidator9OnConvertERKNS_8LocationENS_6OpcodeE: 765| 19.8k|Result SharedValidator::OnConvert(const Location& loc, Opcode opcode) { 766| 19.8k| Result result = CheckInstr(opcode, loc); 767| 19.8k| result |= typechecker_.OnConvert(opcode); 768| 19.8k| return result; 769| 19.8k|} _ZN4wabt15SharedValidator10OnDataDropERKNS_8LocationENS_3VarE: 771| 1|Result SharedValidator::OnDataDrop(const Location& loc, Var segment_var) { 772| 1| Result result = CheckInstr(Opcode::DataDrop, loc); 773| 1| result |= CheckDataSegmentIndex(segment_var); 774| 1| result |= typechecker_.OnDataDrop(segment_var.index()); 775| 1| return result; 776| 1|} _ZN4wabt15SharedValidator6OnDropERKNS_8LocationE: 784| 94|Result SharedValidator::OnDrop(const Location& loc) { 785| 94| Result result = CheckInstr(Opcode::Drop, loc); 786| 94| result |= typechecker_.OnDrop(); 787| 94| return result; 788| 94|} _ZN4wabt15SharedValidator6OnElseERKNS_8LocationE: 797| 183|Result SharedValidator::OnElse(const Location& loc) { 798| | // Don't call CheckInstr or update expr_loc_ here because if we fail we want 799| | // the last expression in the If block to be reported as the error location, 800| | // not the else itself. 801| 183| Result result = Result::Ok; 802| 183| result |= typechecker_.OnElse(); 803| 183| return result; 804| 183|} _ZN4wabt15SharedValidator5OnEndERKNS_8LocationE: 806| 776|Result SharedValidator::OnEnd(const Location& loc) { 807| 776| Result result = CheckInstr(Opcode::End, loc); 808| 776| result |= typechecker_.OnEnd(); 809| 776| return result; 810| 776|} _ZN4wabt15SharedValidator11OnGlobalGetERKNS_8LocationENS_3VarE: 812| 197|Result SharedValidator::OnGlobalGet(const Location& loc, Var global_var) { 813| 197| Result result = CheckInstr(Opcode::GlobalGet, loc); 814| 197| GlobalType global_type; 815| 197| result |= CheckGlobalIndex(global_var, &global_type); 816| 197| result |= typechecker_.OnGlobalGet(global_type.type); 817| 197| if (Succeeded(result) && in_init_expr_) { ------------------ | Branch (817:7): [True: 197, False: 0] | Branch (817:28): [True: 33, False: 164] ------------------ 818| 33| if (global_var.index() >= num_imported_globals_) { ------------------ | Branch (818:9): [True: 3, False: 30] ------------------ 819| 3| result |= PrintError( 820| 3| global_var.loc, 821| 3| "initializer expression can only reference an imported global"); 822| 3| } 823| 33| if (global_type.mutable_) { ------------------ | Branch (823:9): [True: 0, False: 33] ------------------ 824| 0| result |= PrintError( 825| 0| loc, "initializer expression cannot reference a mutable global"); 826| 0| } 827| 33| } 828| | 829| 197| return result; 830| 197|} _ZN4wabt15SharedValidator11OnGlobalSetERKNS_8LocationENS_3VarE: 832| 33|Result SharedValidator::OnGlobalSet(const Location& loc, Var global_var) { 833| 33| Result result = CheckInstr(Opcode::GlobalSet, loc); 834| 33| GlobalType global_type; 835| 33| result |= CheckGlobalIndex(global_var, &global_type); 836| 33| if (!global_type.mutable_) { ------------------ | Branch (836:7): [True: 1, False: 32] ------------------ 837| 1| result |= PrintError( 838| 1| loc, "can't global.set on immutable global at index %" PRIindex ".", 839| 1| global_var.index()); 840| 1| } 841| 33| result |= typechecker_.OnGlobalSet(global_type.type); 842| 33| return result; 843| 33|} _ZN4wabt15SharedValidator4OnIfERKNS_8LocationENS_4TypeE: 845| 552|Result SharedValidator::OnIf(const Location& loc, Type sig_type) { 846| 552| Result result = CheckInstr(Opcode::If, loc); 847| 552| TypeVector param_types, result_types; 848| 552| result |= CheckBlockSignature(loc, Opcode::If, sig_type, ¶m_types, 849| 552| &result_types); 850| 552| result |= typechecker_.OnIf(param_types, result_types); 851| 552| return result; 852| 552|} _ZN4wabt15SharedValidator6OnLoadERKNS_8LocationENS_6OpcodeENS_3VarEmm: 858| 4.18k| Address offset) { 859| 4.18k| Result result = CheckInstr(opcode, loc); 860| 4.18k| MemoryType mt; 861| 4.18k| result |= CheckMemoryIndex(memidx, &mt); 862| 4.18k| result |= CheckAlign(loc, alignment, opcode.GetMemorySize()); 863| 4.18k| result |= CheckOffset(loc, offset, mt.limits); 864| 4.18k| result |= typechecker_.OnLoad(opcode, mt.limits); 865| 4.18k| return result; 866| 4.18k|} _ZN4wabt15SharedValidator11OnLoadSplatERKNS_8LocationENS_6OpcodeENS_3VarEmm: 872| 396| Address offset) { 873| 396| Result result = CheckInstr(opcode, loc); 874| 396| MemoryType mt; 875| 396| result |= CheckMemoryIndex(memidx, &mt); 876| 396| result |= CheckAlign(loc, alignment, opcode.GetMemorySize()); 877| 396| result |= CheckOffset(loc, offset, mt.limits); 878| 396| result |= typechecker_.OnLoad(opcode, mt.limits); 879| 396| return result; 880| 396|} _ZN4wabt15SharedValidator10OnLoadZeroERKNS_8LocationENS_6OpcodeENS_3VarEmm: 886| 444| Address offset) { 887| 444| Result result = CheckInstr(opcode, loc); 888| 444| MemoryType mt; 889| 444| result |= CheckMemoryIndex(memidx, &mt); 890| 444| result |= CheckAlign(loc, alignment, opcode.GetMemorySize()); 891| 444| result |= CheckOffset(loc, offset, mt.limits); 892| 444| result |= typechecker_.OnLoad(opcode, mt.limits); 893| 444| return result; 894| 444|} _ZN4wabt15SharedValidator10OnLocalGetERKNS_8LocationENS_3VarE: 896| 1.94k|Result SharedValidator::OnLocalGet(const Location& loc, Var local_var) { 897| 1.94k| CHECK_RESULT(CheckInstr(Opcode::LocalGet, loc)); ------------------ | | 55| 1.94k| do { \ | | 56| 1.94k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.94k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.94k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 898| 1.94k| Result result = Result::Ok; 899| 1.94k| Type type = Type::Any; 900| 1.94k| result |= CheckLocalIndex(local_var, &type); 901| 1.94k| result |= typechecker_.OnLocalGet(type); 902| 1.94k| return result; 903| 1.94k|} _ZN4wabt15SharedValidator10OnLocalSetERKNS_8LocationENS_3VarE: 905| 729|Result SharedValidator::OnLocalSet(const Location& loc, Var local_var) { 906| 729| CHECK_RESULT(CheckInstr(Opcode::LocalSet, loc)); ------------------ | | 55| 729| do { \ | | 56| 729| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 729] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 729| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 907| 729| Result result = Result::Ok; 908| 729| Type type = Type::Any; 909| 729| result |= CheckLocalIndex(local_var, &type); 910| 729| result |= typechecker_.OnLocalSet(type); 911| 729| return result; 912| 729|} _ZN4wabt15SharedValidator10OnLocalTeeERKNS_8LocationENS_3VarE: 914| 47|Result SharedValidator::OnLocalTee(const Location& loc, Var local_var) { 915| 47| CHECK_RESULT(CheckInstr(Opcode::LocalTee, loc)); ------------------ | | 55| 47| do { \ | | 56| 47| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 47] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 47| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 916| 47| Result result = Result::Ok; 917| 47| Type type = Type::Any; 918| 47| result |= CheckLocalIndex(local_var, &type); 919| 47| result |= typechecker_.OnLocalTee(type); 920| 47| return result; 921| 47|} _ZN4wabt15SharedValidator6OnLoopERKNS_8LocationENS_4TypeE: 923| 602|Result SharedValidator::OnLoop(const Location& loc, Type sig_type) { 924| 602| Result result = CheckInstr(Opcode::Loop, loc); 925| 602| TypeVector param_types, result_types; 926| 602| result |= CheckBlockSignature(loc, Opcode::Loop, sig_type, ¶m_types, 927| 602| &result_types); 928| 602| result |= typechecker_.OnLoop(param_types, result_types); 929| 602| return result; 930| 602|} _ZN4wabt15SharedValidator12OnMemoryFillERKNS_8LocationENS_3VarE: 944| 297|Result SharedValidator::OnMemoryFill(const Location& loc, Var memidx) { 945| 297| Result result = CheckInstr(Opcode::MemoryFill, loc); 946| 297| MemoryType mt; 947| 297| result |= CheckMemoryIndex(memidx, &mt); 948| 297| result |= typechecker_.OnMemoryFill(mt.limits); 949| 297| return result; 950| 297|} _ZN4wabt15SharedValidator12OnMemoryGrowERKNS_8LocationENS_3VarE: 952| 94|Result SharedValidator::OnMemoryGrow(const Location& loc, Var memidx) { 953| 94| Result result = CheckInstr(Opcode::MemoryGrow, loc); 954| 94| MemoryType mt; 955| 94| result |= CheckMemoryIndex(memidx, &mt); 956| 94| result |= typechecker_.OnMemoryGrow(mt.limits); 957| 94| return result; 958| 94|} _ZN4wabt15SharedValidator12OnMemorySizeERKNS_8LocationENS_3VarE: 971| 4|Result SharedValidator::OnMemorySize(const Location& loc, Var memidx) { 972| 4| Result result = CheckInstr(Opcode::MemorySize, loc); 973| 4| MemoryType mt; 974| 4| result |= CheckMemoryIndex(memidx, &mt); 975| 4| result |= typechecker_.OnMemorySize(mt.limits); 976| 4| return result; 977| 4|} _ZN4wabt15SharedValidator5OnNopERKNS_8LocationE: 979| 32.7k|Result SharedValidator::OnNop(const Location& loc) { 980| 32.7k| Result result = CheckInstr(Opcode::Nop, loc); 981| 32.7k| return result; 982| 32.7k|} _ZN4wabt15SharedValidator9OnRefFuncERKNS_8LocationENS_3VarE: 984| 95|Result SharedValidator::OnRefFunc(const Location& loc, Var func_var) { 985| 95| Result result = CheckInstr(Opcode::RefFunc, loc); 986| 95| result |= CheckFuncIndex(func_var); 987| 95| if (Succeeded(result)) { ------------------ | Branch (987:7): [True: 89, False: 6] ------------------ 988| | // References in initializer expressions are considered declarations, as 989| | // opposed to references in function bodies that are considered usages. 990| 89| if (in_init_expr_) { ------------------ | Branch (990:9): [True: 77, False: 12] ------------------ 991| 77| declared_funcs_.insert(func_var.index()); 992| 77| } else { 993| 12| check_declared_funcs_.push_back(func_var); 994| 12| } 995| 89| Index func_type = GetFunctionTypeIndex(func_var.index()); 996| 89| result |= typechecker_.OnRefFuncExpr(func_type, in_init_expr_); 997| 89| } 998| 95| return result; 999| 95|} _ZN4wabt15SharedValidator11OnRefIsNullERKNS_8LocationE: 1001| 34|Result SharedValidator::OnRefIsNull(const Location& loc) { 1002| 34| Result result = CheckInstr(Opcode::RefIsNull, loc); 1003| 34| result |= typechecker_.OnRefIsNullExpr(); 1004| 34| return result; 1005| 34|} _ZN4wabt15SharedValidator9OnRefNullERKNS_8LocationENS_4TypeE: 1007| 27|Result SharedValidator::OnRefNull(const Location& loc, Type type) { 1008| 27| Result result = CheckInstr(Opcode::RefNull, loc); 1009| 27| result |= typechecker_.OnRefNullExpr(type); 1010| 27| return result; 1011| 27|} _ZN4wabt15SharedValidator9OnRethrowERKNS_8LocationENS_3VarE: 1013| 4|Result SharedValidator::OnRethrow(const Location& loc, Var depth) { 1014| 4| Result result = CheckInstr(Opcode::Rethrow, loc); 1015| 4| result |= typechecker_.OnRethrow(depth.index()); 1016| 4| return result; 1017| 4|} _ZN4wabt15SharedValidator12OnReturnCallERKNS_8LocationENS_3VarE: 1019| 4|Result SharedValidator::OnReturnCall(const Location& loc, Var func_var) { 1020| 4| Result result = CheckInstr(Opcode::ReturnCall, loc); 1021| 4| FuncType func_type; 1022| 4| result |= CheckFuncIndex(func_var, &func_type); 1023| 4| result |= typechecker_.OnReturnCall(func_type.params, func_type.results); 1024| 4| return result; 1025| 4|} _ZN4wabt15SharedValidator20OnReturnCallIndirectERKNS_8LocationENS_3VarES4_: 1029| 222| Var table_var) { 1030| 222| Result result = CheckInstr(Opcode::CallIndirect, loc); 1031| 222| result |= CheckTableIndex(table_var); 1032| 222| FuncType func_type; 1033| 222| result |= CheckFuncTypeIndex(sig_var, &func_type); 1034| 222| result |= 1035| 222| typechecker_.OnReturnCallIndirect(func_type.params, func_type.results); 1036| 222| return result; 1037| 222|} _ZN4wabt15SharedValidator8OnReturnERKNS_8LocationE: 1039| 1.72k|Result SharedValidator::OnReturn(const Location& loc) { 1040| 1.72k| Result result = CheckInstr(Opcode::Return, loc); 1041| 1.72k| result |= typechecker_.OnReturn(); 1042| 1.72k| return result; 1043| 1.72k|} _ZN4wabt15SharedValidator8OnSelectERKNS_8LocationEjPNS_4TypeE: 1047| 966| Type* result_types) { 1048| 966| Result result = CheckInstr(Opcode::Select, loc); 1049| 966| if (result_count > 1) { ------------------ | Branch (1049:7): [True: 0, False: 966] ------------------ 1050| 0| result |= 1051| 0| PrintError(loc, "invalid arity in select instruction: %" PRIindex ".", 1052| 0| result_count); 1053| 966| } else { 1054| 966| result |= typechecker_.OnSelect(ToTypeVector(result_count, result_types)); 1055| 966| } 1056| 966| return result; 1057| 966|} _ZN4wabt15SharedValidator12OnSimdLaneOpERKNS_8LocationENS_6OpcodeEm: 1061| 1.02k| uint64_t value) { 1062| 1.02k| Result result = CheckInstr(opcode, loc); 1063| 1.02k| result |= typechecker_.OnSimdLaneOp(opcode, value); 1064| 1.02k| return result; 1065| 1.02k|} _ZN4wabt15SharedValidator14OnSimdLoadLaneERKNS_8LocationENS_6OpcodeENS_3VarEmmm: 1072| 169| uint64_t value) { 1073| 169| Result result = CheckInstr(opcode, loc); 1074| 169| MemoryType mt; 1075| 169| result |= CheckMemoryIndex(memidx, &mt); 1076| 169| result |= CheckAlign(loc, alignment, opcode.GetMemorySize()); 1077| 169| result |= CheckOffset(loc, offset, mt.limits); 1078| 169| result |= typechecker_.OnSimdLoadLane(opcode, mt.limits, value); 1079| 169| return result; 1080| 169|} _ZN4wabt15SharedValidator15OnSimdStoreLaneERKNS_8LocationENS_6OpcodeENS_3VarEmmm: 1087| 201| uint64_t value) { 1088| 201| Result result = CheckInstr(opcode, loc); 1089| 201| MemoryType mt; 1090| 201| result |= CheckMemoryIndex(memidx, &mt); 1091| 201| result |= CheckAlign(loc, alignment, opcode.GetMemorySize()); 1092| 201| result |= CheckOffset(loc, offset, mt.limits); 1093| 201| result |= typechecker_.OnSimdStoreLane(opcode, mt.limits, value); 1094| 201| return result; 1095| 201|} _ZN4wabt15SharedValidator15OnSimdShuffleOpERKNS_8LocationENS_6OpcodeE4v128: 1099| 4| v128 value) { 1100| 4| Result result = CheckInstr(opcode, loc); 1101| 4| result |= typechecker_.OnSimdShuffleOp(opcode, value); 1102| 4| return result; 1103| 4|} _ZN4wabt15SharedValidator7OnStoreERKNS_8LocationENS_6OpcodeENS_3VarEmm: 1109| 333| Address offset) { 1110| 333| Result result = CheckInstr(opcode, loc); 1111| 333| MemoryType mt; 1112| 333| result |= CheckMemoryIndex(memidx, &mt); 1113| 333| result |= CheckAlign(loc, alignment, opcode.GetMemorySize()); 1114| 333| result |= CheckOffset(loc, offset, mt.limits); 1115| 333| result |= typechecker_.OnStore(opcode, mt.limits); 1116| 333| return result; 1117| 333|} _ZN4wabt15SharedValidator11OnTableCopyERKNS_8LocationENS_3VarES4_: 1121| 53| Var src_var) { 1122| 53| Result result = CheckInstr(Opcode::TableCopy, loc); 1123| 53| TableType dst_table; 1124| 53| TableType src_table; 1125| 53| result |= CheckTableIndex(dst_var, &dst_table); 1126| 53| result |= CheckTableIndex(src_var, &src_table); 1127| 53| result |= typechecker_.OnTableCopy(dst_table.limits, src_table.limits); 1128| 53| result |= CheckType(loc, src_table.element, dst_table.element, "table.copy"); 1129| 53| return result; 1130| 53|} _ZN4wabt15SharedValidator11OnTableFillERKNS_8LocationENS_3VarE: 1132| 65|Result SharedValidator::OnTableFill(const Location& loc, Var table_var) { 1133| 65| Result result = CheckInstr(Opcode::TableFill, loc); 1134| 65| TableType table_type; 1135| 65| result |= CheckTableIndex(table_var, &table_type); 1136| 65| result |= typechecker_.OnTableFill(table_type.element, table_type.limits); 1137| 65| return result; 1138| 65|} _ZN4wabt15SharedValidator10OnTableGetERKNS_8LocationENS_3VarE: 1140| 50|Result SharedValidator::OnTableGet(const Location& loc, Var table_var) { 1141| 50| Result result = CheckInstr(Opcode::TableGet, loc); 1142| 50| TableType table_type; 1143| 50| result |= CheckTableIndex(table_var, &table_type); 1144| 50| result |= typechecker_.OnTableGet(table_type.element, table_type.limits); 1145| 50| return result; 1146| 50|} _ZN4wabt15SharedValidator10OnTableSetERKNS_8LocationENS_3VarE: 1169| 94|Result SharedValidator::OnTableSet(const Location& loc, Var table_var) { 1170| 94| Result result = CheckInstr(Opcode::TableSet, loc); 1171| 94| TableType table_type; 1172| 94| result |= CheckTableIndex(table_var, &table_type); 1173| 94| result |= typechecker_.OnTableSet(table_type.element, table_type.limits); 1174| 94| return result; 1175| 94|} _ZN4wabt15SharedValidator7OnThrowERKNS_8LocationENS_3VarE: 1191| 1|Result SharedValidator::OnThrow(const Location& loc, Var tag_var) { 1192| 1| Result result = CheckInstr(Opcode::Throw, loc); 1193| 1| TagType tag_type; 1194| 1| result |= CheckTagIndex(tag_var, &tag_type); 1195| 1| result |= typechecker_.OnThrow(tag_type.params); 1196| 1| return result; 1197| 1|} _ZN4wabt15SharedValidator5OnTryERKNS_8LocationENS_4TypeE: 1199| 1|Result SharedValidator::OnTry(const Location& loc, Type sig_type) { 1200| 1| Result result = CheckInstr(Opcode::Try, loc); 1201| 1| TypeVector param_types, result_types; 1202| 1| result |= CheckBlockSignature(loc, Opcode::Try, sig_type, ¶m_types, 1203| 1| &result_types); 1204| 1| result |= typechecker_.OnTry(param_types, result_types); 1205| 1| return result; 1206| 1|} _ZN4wabt15SharedValidator7OnUnaryERKNS_8LocationENS_6OpcodeE: 1208| 33.4k|Result SharedValidator::OnUnary(const Location& loc, Opcode opcode) { 1209| 33.4k| Result result = CheckInstr(opcode, loc); 1210| 33.4k| result |= typechecker_.OnUnary(opcode); 1211| 33.4k| return result; 1212| 33.4k|} _ZN4wabt15SharedValidator13OnUnreachableERKNS_8LocationE: 1214| 188k|Result SharedValidator::OnUnreachable(const Location& loc) { 1215| 188k| Result result = CheckInstr(Opcode::Unreachable, loc); 1216| 188k| result |= typechecker_.OnUnreachable(); 1217| 188k| return result; 1218| 188k|} shared-validator.cc:_ZN4wabtL15is_power_of_twoEj: 478| 5.74k|static bool is_power_of_two(uint32_t x) { 479| 5.74k| return x && ((x & (x - 1)) == 0); ------------------ | Branch (479:10): [True: 5.74k, False: 0] | Branch (479:15): [True: 5.74k, False: 6] ------------------ 480| 5.74k|} shared-validator.cc:_ZZN4wabt15SharedValidatorC1EPNSt3__16vectorINS_5ErrorENS1_9allocatorIS3_EEEERKNS_15ValidateOptionsEENK3$_0clEPKc: 32| 207| [this](const char* msg) { OnTypecheckerError(msg); }); shared-validator.cc:_ZZN4wabt15SharedValidator15CheckLocalIndexENS_3VarEPNS_4TypeEENK3$_0clEjRKNS0_9LocalDeclE: 338| 3.79k| [](Index index, const LocalDecl& decl) { return index < decl.end; }); _ZN4wabt15SharedValidator19CheckIndexWithValueINS0_8FuncTypeEEENS_6ResultENS_3VarERKNSt3__16vectorIT_NS5_9allocatorIS7_EEEEPS7_PKc: 327| 2.77k| const char* desc) { 328| 2.77k| Result result = CheckIndex(var, values.size(), desc); 329| 2.77k| if (out) { ------------------ | Branch (329:7): [True: 656, False: 2.12k] ------------------ 330| 656| *out = Succeeded(result) ? values[var.index()] : T{}; ------------------ | Branch (330:12): [True: 644, False: 12] ------------------ 331| 656| } 332| 2.77k| return result; 333| 2.77k|} _ZN4wabt15SharedValidator19CheckIndexWithValueINS0_10MemoryTypeEEENS_6ResultENS_3VarERKNSt3__16vectorIT_NS5_9allocatorIS7_EEEEPS7_PKc: 327| 6.15k| const char* desc) { 328| 6.15k| Result result = CheckIndex(var, values.size(), desc); 329| 6.15k| if (out) { ------------------ | Branch (329:7): [True: 6.14k, False: 11] ------------------ 330| 6.14k| *out = Succeeded(result) ? values[var.index()] : T{}; ------------------ | Branch (330:12): [True: 6.12k, False: 21] ------------------ 331| 6.14k| } 332| 6.15k| return result; 333| 6.15k|} _ZN4wabt15SharedValidator19CheckIndexWithValueINS0_9TableTypeEEENS_6ResultENS_3VarERKNSt3__16vectorIT_NS5_9allocatorIS7_EEEEPS7_PKc: 327| 897| const char* desc) { 328| 897| Result result = CheckIndex(var, values.size(), desc); 329| 897| if (out) { ------------------ | Branch (329:7): [True: 673, False: 224] ------------------ 330| 673| *out = Succeeded(result) ? values[var.index()] : T{}; ------------------ | Branch (330:12): [True: 662, False: 11] ------------------ 331| 673| } 332| 897| return result; 333| 897|} _ZN4wabt15SharedValidator19CheckIndexWithValueINS0_10GlobalTypeEEENS_6ResultENS_3VarERKNSt3__16vectorIT_NS5_9allocatorIS7_EEEEPS7_PKc: 327| 235| const char* desc) { 328| 235| Result result = CheckIndex(var, values.size(), desc); 329| 235| if (out) { ------------------ | Branch (329:7): [True: 230, False: 5] ------------------ 330| 230| *out = Succeeded(result) ? values[var.index()] : T{}; ------------------ | Branch (330:12): [True: 229, False: 1] ------------------ 331| 230| } 332| 235| return result; 333| 235|} _ZN4wabt15SharedValidator19CheckIndexWithValueINS0_7TagTypeEEENS_6ResultENS_3VarERKNSt3__16vectorIT_NS5_9allocatorIS7_EEEEPS7_PKc: 327| 6| const char* desc) { 328| 6| Result result = CheckIndex(var, values.size(), desc); 329| 6| if (out) { ------------------ | Branch (329:7): [True: 5, False: 1] ------------------ 330| 5| *out = Succeeded(result) ? values[var.index()] : T{}; ------------------ | Branch (330:12): [True: 0, False: 5] ------------------ 331| 5| } 332| 6| return result; 333| 6|} _ZN4wabt11TypeChecker5LabelC2ENS_9LabelTypeERKNSt3__16vectorINS_4TypeENS3_9allocatorIS5_EEEESA_m: 52| 5.55k| unreachable(false) {} _ZN4wabt11TypeChecker10PrintErrorEPKcz: 54| 207|void TypeChecker::PrintError(const char* fmt, ...) { 55| 207| if (error_callback_) { ------------------ | Branch (55:7): [True: 207, False: 0] ------------------ 56| 207| WABT_SNPRINTF_ALLOCA(buffer, length, fmt); ------------------ | | 36| 207| va_list args; \ | | 37| 207| va_list args_copy; \ | | 38| 207| va_start(args, format); \ | | 39| 207| va_copy(args_copy, args); \ | | 40| 207| char fixed_buf[WABT_DEFAULT_SNPRINTF_ALLOCA_BUFSIZE]; \ | | 41| 207| char* buffer = fixed_buf; \ | | 42| 207| size_t len = wabt_vsnprintf(fixed_buf, sizeof(fixed_buf), format, args); \ | | ------------------ | | | | 301| 207|#define wabt_vsnprintf vsnprintf | | ------------------ | | 43| 207| va_end(args); \ | | 44| 207| if (len + 1 > sizeof(fixed_buf)) { \ | | ------------------ | | | Branch (44:7): [True: 0, False: 207] | | ------------------ | | 45| 0| buffer = static_cast(alloca(len + 1)); \ | | 46| 0| len = wabt_vsnprintf(buffer, len + 1, format, args_copy); \ | | ------------------ | | | | 301| 0|#define wabt_vsnprintf vsnprintf | | ------------------ | | 47| 0| } \ | | 48| 207| va_end(args_copy) ------------------ 57| 207| error_callback_(buffer); 58| 207| } 59| 207|} _ZN4wabt11TypeChecker8GetLabelEjPPNS0_5LabelE: 61| 533k|Result TypeChecker::GetLabel(Index depth, Label** out_label) { 62| 533k| if (depth >= label_stack_.size()) { ------------------ | Branch (62:7): [True: 18, False: 533k] ------------------ 63| 18| assert(label_stack_.size() > 0); 64| 18| PrintError("invalid depth: %" PRIindex " (max %" PRIzd ")", depth, 65| 18| label_stack_.size() - 1); 66| 18| *out_label = nullptr; 67| 18| return Result::Error; 68| 18| } 69| 533k| *out_label = &label_stack_[label_stack_.size() - depth - 1]; 70| 533k| return Result::Ok; 71| 533k|} _ZN4wabt11TypeChecker15GetRethrowLabelEjPPNS0_5LabelE: 73| 4|Result TypeChecker::GetRethrowLabel(Index depth, Label** out_label) { 74| 4| if (Failed(GetLabel(depth, out_label))) { ------------------ | Branch (74:7): [True: 1, False: 3] ------------------ 75| 1| return Result::Error; 76| 1| } 77| | 78| 3| if ((*out_label)->label_type == LabelType::Catch) { ------------------ | Branch (78:7): [True: 0, False: 3] ------------------ 79| 0| return Result::Ok; 80| 0| } 81| | 82| 3| std::string candidates; 83| 144| for (Index idx = 0; idx < label_stack_.size(); idx++) { ------------------ | Branch (83:23): [True: 141, False: 3] ------------------ 84| 141| LabelType type = label_stack_[label_stack_.size() - idx - 1].label_type; 85| 141| if (type == LabelType::Catch) { ------------------ | Branch (85:9): [True: 0, False: 141] ------------------ 86| 0| if (!candidates.empty()) { ------------------ | Branch (86:11): [True: 0, False: 0] ------------------ 87| 0| candidates.append(", "); 88| 0| } 89| 0| candidates.append(std::to_string(idx)); 90| 0| } 91| 141| } 92| | 93| 3| if (candidates.empty()) { ------------------ | Branch (93:7): [True: 3, False: 0] ------------------ 94| 3| PrintError("rethrow not in try catch block"); 95| 3| } else { 96| 0| PrintError("invalid rethrow depth: %" PRIindex " (catches: %s)", depth, 97| 0| candidates.c_str()); 98| 0| } 99| 3| *out_label = nullptr; 100| 3| return Result::Error; 101| 3|} _ZN4wabt11TypeChecker13GetCatchCountEjPj: 103| 5.85k|Result TypeChecker::GetCatchCount(Index depth, Index* out_count) { 104| 5.85k| Label* unused; 105| 5.85k| if (Failed(GetLabel(depth, &unused))) { ------------------ | Branch (105:7): [True: 0, False: 5.85k] ------------------ 106| 0| return Result::Error; 107| 0| } 108| | 109| 5.85k| Index catch_count = 0; 110| 23.9k| for (Index idx = 0; idx <= depth; idx++) { ------------------ | Branch (110:23): [True: 18.1k, False: 5.85k] ------------------ 111| 18.1k| LabelType type = label_stack_[label_stack_.size() - idx - 1].label_type; 112| 18.1k| if (type == LabelType::Catch) { ------------------ | Branch (112:9): [True: 0, False: 18.1k] ------------------ 113| 0| catch_count++; 114| 0| } 115| 18.1k| } 116| 5.85k| *out_count = catch_count; 117| | 118| 5.85k| return Result::Ok; 119| 5.85k|} _ZN4wabt11TypeChecker8TopLabelEPPNS0_5LabelE: 121| 513k|Result TypeChecker::TopLabel(Label** out_label) { 122| 513k| return GetLabel(0, out_label); 123| 513k|} _ZN4wabt11TypeChecker21ResetTypeStackToLabelEPNS0_5LabelE: 133| 294k|void TypeChecker::ResetTypeStackToLabel(Label* label) { 134| 294k| type_stack_.resize(label->type_stack_limit); 135| 294k|} _ZN4wabt11TypeChecker14SetUnreachableEv: 137| 191k|Result TypeChecker::SetUnreachable() { 138| 191k| Label* label; 139| 191k| CHECK_RESULT(TopLabel(&label)); ------------------ | | 55| 191k| do { \ | | 56| 191k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 191k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 191k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 140| 191k| label->unreachable = true; 141| 191k| ResetTypeStackToLabel(label); 142| 191k| return Result::Ok; 143| 191k|} _ZN4wabt11TypeChecker9PushLabelENS_9LabelTypeERKNSt3__16vectorINS_4TypeENS2_9allocatorIS4_EEEES9_: 147| 5.55k| const TypeVector& result_types) { 148| 5.55k| label_stack_.emplace_back(label_type, param_types, result_types, 149| 5.55k| type_stack_.size()); 150| 5.55k|} _ZN4wabt11TypeChecker8PopLabelEv: 152| 2.91k|Result TypeChecker::PopLabel() { 153| 2.91k| label_stack_.pop_back(); 154| 2.91k| return Result::Ok; 155| 2.91k|} _ZN4wabt11TypeChecker14CheckLabelTypeEPNS0_5LabelENS_9LabelTypeE: 157| 2.41k|Result TypeChecker::CheckLabelType(Label* label, LabelType label_type) { 158| 2.41k| return label->label_type == label_type ? Result::Ok : Result::Error; ------------------ | Branch (158:10): [True: 2.41k, False: 0] ------------------ 159| 2.41k|} _ZN4wabt11TypeChecker16Check2LabelTypesEPNS0_5LabelENS_9LabelTypeES3_: 163| 4| LabelType label_type2) { 164| 4| return label->label_type == label_type1 || label->label_type == label_type2 ------------------ | Branch (164:10): [True: 0, False: 4] | Branch (164:46): [True: 0, False: 4] ------------------ 165| 4| ? Result::Ok 166| 4| : Result::Error; 167| 4|} _ZN4wabt11TypeChecker20GetThisFunctionLabelEPPNS0_5LabelE: 169| 1.95k|Result TypeChecker::GetThisFunctionLabel(Label** label) { 170| 1.95k| return GetLabel(label_stack_.size() - 1, label); 171| 1.95k|} _ZN4wabt11TypeChecker8PeekTypeEjPNS_4TypeE: 173| 184k|Result TypeChecker::PeekType(Index depth, Type* out_type) { 174| 184k| Label* label; 175| 184k| CHECK_RESULT(TopLabel(&label)); ------------------ | | 55| 184k| do { \ | | 56| 184k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 184k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 184k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 176| | 177| 184k| if (label->type_stack_limit + depth >= type_stack_.size()) { ------------------ | Branch (177:7): [True: 119k, False: 65.3k] ------------------ 178| 119k| *out_type = Type::Any; 179| 119k| return label->unreachable ? Result::Ok : Result::Error; ------------------ | Branch (179:12): [True: 119k, False: 45] ------------------ 180| 119k| } 181| 65.3k| *out_type = type_stack_[type_stack_.size() - depth - 1]; 182| 65.3k| return Result::Ok; 183| 184k|} _ZN4wabt11TypeChecker16PeekAndCheckTypeEjNS_4TypeE: 185| 182k|Result TypeChecker::PeekAndCheckType(Index depth, Type expected) { 186| 182k| Type actual = Type::Any; 187| 182k| Result result = PeekType(depth, &actual); 188| 182k| return result | CheckType(actual, expected); 189| 182k|} _ZN4wabt11TypeChecker9DropTypesEm: 191| 130k|Result TypeChecker::DropTypes(size_t drop_count) { 192| 130k| Label* label; 193| 130k| CHECK_RESULT(TopLabel(&label)); ------------------ | | 55| 130k| do { \ | | 56| 130k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 130k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 130k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 194| 130k| if (label->type_stack_limit + drop_count > type_stack_.size()) { ------------------ | Branch (194:7): [True: 99.3k, False: 30.9k] ------------------ 195| 99.3k| ResetTypeStackToLabel(label); 196| 99.3k| return label->unreachable ? Result::Ok : Result::Error; ------------------ | Branch (196:12): [True: 99.3k, False: 27] ------------------ 197| 99.3k| } 198| 30.9k| type_stack_.erase(type_stack_.end() - drop_count, type_stack_.end()); 199| 30.9k| return Result::Ok; 200| 130k|} _ZN4wabt11TypeChecker8PushTypeENS_4TypeE: 202| 149k|void TypeChecker::PushType(Type type) { 203| 149k| if (type != Type::Void) { ------------------ | Branch (203:7): [True: 148k, False: 935] ------------------ 204| 148k| type_stack_.push_back(type); 205| 148k| } 206| 149k|} _ZN4wabt11TypeChecker9PushTypesERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEE: 208| 7.22k|void TypeChecker::PushTypes(const TypeVector& types) { 209| 7.22k| for (Type type : types) { ------------------ | Branch (209:18): [True: 2.91k, False: 7.22k] ------------------ 210| 2.91k| PushType(type); 211| 2.91k| } 212| 7.22k|} _ZN4wabt11TypeChecker17CheckTypeStackEndEPKc: 214| 3.19k|Result TypeChecker::CheckTypeStackEnd(const char* desc) { 215| 3.19k| Label* label; 216| 3.19k| CHECK_RESULT(TopLabel(&label)); ------------------ | | 55| 3.19k| do { \ | | 56| 3.19k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 3.19k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 3.19k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 217| 3.19k| Result result = (type_stack_.size() == label->type_stack_limit) ------------------ | Branch (217:19): [True: 3.18k, False: 10] ------------------ 218| 3.19k| ? Result::Ok 219| 3.19k| : Result::Error; 220| 3.19k| PrintStackIfFailedV(result, desc, {}, /*is_end=*/true); 221| 3.19k| return result; 222| 3.19k|} _ZN4wabt11TypeChecker9CheckTypeENS_4TypeES1_: 224| 183k|Result TypeChecker::CheckType(Type actual, Type expected) { 225| 183k| if (expected == Type::Any || actual == Type::Any) { ------------------ | Branch (225:7): [True: 736, False: 183k] | Branch (225:32): [True: 118k, False: 64.9k] ------------------ 226| 118k| return Result::Ok; 227| 118k| } 228| | 229| 64.9k| if (expected == Type::Reference && actual == Type::Reference) { ------------------ | Branch (229:7): [True: 0, False: 64.9k] | Branch (229:38): [True: 0, False: 0] ------------------ 230| 0| return expected.GetReferenceIndex() == actual.GetReferenceIndex() ------------------ | Branch (230:12): [True: 0, False: 0] ------------------ 231| 0| ? Result::Ok 232| 0| : Result::Error; 233| 0| } 234| 64.9k| if (actual != expected) { ------------------ | Branch (234:7): [True: 93, False: 64.8k] ------------------ 235| 93| return Result::Error; 236| 93| } 237| 64.8k| return Result::Ok; 238| 64.9k|} _ZN4wabt11TypeChecker10CheckTypesERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEES8_: 241| 226| const TypeVector& expected) { 242| 226| if (actual.size() != expected.size()) { ------------------ | Branch (242:7): [True: 1, False: 225] ------------------ 243| 1| return Result::Error; 244| 225| } else { 245| 225| Result result = Result::Ok; 246| 227| for (size_t i = 0; i < actual.size(); i++) ------------------ | Branch (246:24): [True: 2, False: 225] ------------------ 247| 2| result |= CheckType(actual[i], expected[i]); 248| 225| return result; 249| 225| } 250| 226|} _ZN4wabt11TypeChecker14CheckSignatureERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEEPKc: 252| 13.1k|Result TypeChecker::CheckSignature(const TypeVector& sig, const char* desc) { 253| 13.1k| Result result = Result::Ok; 254| 16.9k| for (size_t i = 0; i < sig.size(); ++i) { ------------------ | Branch (254:22): [True: 3.79k, False: 13.1k] ------------------ 255| 3.79k| result |= PeekAndCheckType(sig.size() - i - 1, sig[i]); 256| 3.79k| } 257| 13.1k| PrintStackIfFailedV(result, desc, sig, /*is_end=*/false); 258| 13.1k| return result; 259| 13.1k|} _ZN4wabt11TypeChecker20CheckReturnSignatureERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEES8_PKc: 263| 226| const char* desc) { 264| 226| Result result = CheckTypes(actual, expected); 265| 226| if (Failed(result)) { ------------------ | Branch (265:7): [True: 1, False: 225] ------------------ 266| 1| PrintError("return signatures have inconsistent types: expected %s, got %s", 267| 1| TypesToString(expected).c_str(), TypesToString(actual).c_str()); 268| 1| } 269| 226| return result; 270| 226|} _ZN4wabt11TypeChecker20PopAndCheckSignatureERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEEPKc: 273| 8.19k| const char* desc) { 274| 8.19k| Result result = CheckSignature(sig, desc); 275| 8.19k| result |= DropTypes(sig.size()); 276| 8.19k| return result; 277| 8.19k|} _ZN4wabt11TypeChecker15PopAndCheckCallERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEES8_PKc: 281| 981| const char* desc) { 282| 981| Result result = CheckSignature(param_types, desc); 283| 981| result |= DropTypes(param_types.size()); 284| 981| PushTypes(result_types); 285| 981| return result; 286| 981|} _ZN4wabt11TypeChecker16PopAndCheck1TypeENS_4TypeEPKc: 288| 62.4k|Result TypeChecker::PopAndCheck1Type(Type expected, const char* desc) { 289| 62.4k| Result result = Result::Ok; 290| 62.4k| result |= PeekAndCheckType(0, expected); 291| 62.4k| PrintStackIfFailed(result, desc, expected); 292| 62.4k| result |= DropTypes(1); 293| 62.4k| return result; 294| 62.4k|} _ZN4wabt11TypeChecker17PopAndCheck2TypesENS_4TypeES1_PKc: 298| 57.1k| const char* desc) { 299| 57.1k| Result result = Result::Ok; 300| 57.1k| result |= PeekAndCheckType(0, expected2); 301| 57.1k| result |= PeekAndCheckType(1, expected1); 302| 57.1k| PrintStackIfFailed(result, desc, expected1, expected2); 303| 57.1k| result |= DropTypes(2); 304| 57.1k| return result; 305| 57.1k|} _ZN4wabt11TypeChecker17PopAndCheck3TypesENS_4TypeES1_S1_PKc: 310| 415| const char* desc) { 311| 415| Result result = Result::Ok; 312| 415| result |= PeekAndCheckType(0, expected3); 313| 415| result |= PeekAndCheckType(1, expected2); 314| 415| result |= PeekAndCheckType(2, expected1); 315| 415| PrintStackIfFailed(result, desc, expected1, expected2, expected3); 316| 415| result |= DropTypes(3); 317| 415| return result; 318| 415|} _ZN4wabt11TypeChecker12CheckOpcode1ENS_6OpcodeEPKNS_6LimitsE: 326| 59.0k|Result TypeChecker::CheckOpcode1(Opcode opcode, const Limits* limits) { 327| 59.0k| Result result = PopAndCheck1Type( 328| 59.0k| GetMemoryParam(opcode.GetParamType1(), limits), opcode.GetName()); 329| 59.0k| PushType(opcode.GetResultType()); 330| 59.0k| return result; 331| 59.0k|} _ZN4wabt11TypeChecker12CheckOpcode2ENS_6OpcodeEPKNS_6LimitsE: 333| 57.0k|Result TypeChecker::CheckOpcode2(Opcode opcode, const Limits* limits) { 334| 57.0k| Result result = 335| 57.0k| PopAndCheck2Types(GetMemoryParam(opcode.GetParamType1(), limits), 336| 57.0k| opcode.GetParamType2(), opcode.GetName()); 337| 57.0k| PushType(opcode.GetResultType()); 338| 57.0k| return result; 339| 57.0k|} _ZN4wabt11TypeChecker12CheckOpcode3ENS_6OpcodeEPKNS_6LimitsES4_S4_: 344| 350| const Limits* limits3) { 345| 350| Result result = PopAndCheck3Types( 346| 350| GetMemoryParam(opcode.GetParamType1(), limits1), 347| 350| GetMemoryParam(opcode.GetParamType2(), limits2), 348| 350| GetMemoryParam(opcode.GetParamType3(), limits3), opcode.GetName()); 349| 350| PushType(opcode.GetResultType()); 350| 350| return result; 351| 350|} _ZN4wabt11TypeChecker19PrintStackIfFailedVENS_6ResultEPKcRKNSt3__16vectorINS_4TypeENS4_9allocatorIS6_EEEEb: 356| 16.4k| bool is_end) { 357| 16.4k| if (Succeeded(result)) { ------------------ | Branch (357:7): [True: 16.3k, False: 118] ------------------ 358| 16.3k| return; 359| 16.3k| } 360| | 361| 118| size_t limit = 0; 362| 118| Label* label; 363| 118| if (Succeeded(TopLabel(&label))) { ------------------ | Branch (363:7): [True: 118, False: 0] ------------------ 364| 118| limit = label->type_stack_limit; 365| 118| } 366| | 367| 118| TypeVector actual; 368| 118| size_t max_depth = type_stack_.size() - limit; 369| | 370| | // In general we want to print as many values of the actual stack as were 371| | // expected. However, if the stack was expected to be empty, we should 372| | // print some amount of the actual stack. 373| 118| size_t actual_size; 374| 118| if (expected.size() == 0) { ------------------ | Branch (374:7): [True: 10, False: 108] ------------------ 375| | // Don't print too many elements if the stack is really deep. 376| 10| const size_t kMaxActualStackToPrint = 4; 377| 10| actual_size = std::min(kMaxActualStackToPrint, max_depth); 378| 108| } else { 379| 108| actual_size = std::min(expected.size(), max_depth); 380| 108| } 381| | 382| 118| bool incomplete_actual_stack = actual_size != max_depth; 383| | 384| 248| for (size_t i = 0; i < actual_size; ++i) { ------------------ | Branch (384:22): [True: 130, False: 118] ------------------ 385| 130| Type type; 386| 130| Result result = PeekType(actual_size - i - 1, &type); 387| 130| WABT_USE(result); ------------------ | | 44| 130|#define WABT_USE(x) static_cast(x) ------------------ 388| 130| assert(Succeeded(result)); 389| 130| actual.push_back(type); 390| 130| } 391| | 392| 118| std::string message = "type mismatch in "; 393| 118| if (is_end) { ------------------ | Branch (393:7): [True: 10, False: 108] ------------------ 394| 10| message = "type mismatch at end of "; 395| 10| } 396| 118| message += desc; 397| 118| message += ", expected "; 398| 118| message += TypesToString(expected); 399| 118| message += " but got "; 400| 118| message += TypesToString(actual, incomplete_actual_stack ? "... " : nullptr); ------------------ | Branch (400:36): [True: 23, False: 95] ------------------ 401| | 402| 118| PrintError("%s", message.c_str()); 403| 118|} _ZN4wabt11TypeChecker13BeginFunctionERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEE: 405| 2.23k|Result TypeChecker::BeginFunction(const TypeVector& sig) { 406| 2.23k| type_stack_.clear(); 407| 2.23k| label_stack_.clear(); 408| 2.23k| PushLabel(LabelType::Func, TypeVector(), sig); 409| 2.23k| return Result::Ok; 410| 2.23k|} _ZN4wabt11TypeChecker13OnAtomicStoreENS_6OpcodeERKNS_6LimitsE: 416| 1|Result TypeChecker::OnAtomicStore(Opcode opcode, const Limits& limits) { 417| 1| return CheckOpcode2(opcode, &limits); 418| 1|} _ZN4wabt11TypeChecker11OnAtomicRmwENS_6OpcodeERKNS_6LimitsE: 420| 15|Result TypeChecker::OnAtomicRmw(Opcode opcode, const Limits& limits) { 421| 15| return CheckOpcode2(opcode, &limits); 422| 15|} _ZN4wabt11TypeChecker13OnAtomicFenceEj: 432| 234|Result TypeChecker::OnAtomicFence(uint32_t consistency_model) { 433| 234| return Result::Ok; 434| 234|} _ZN4wabt11TypeChecker14OnAtomicNotifyENS_6OpcodeERKNS_6LimitsE: 436| 1|Result TypeChecker::OnAtomicNotify(Opcode opcode, const Limits& limits) { 437| 1| return CheckOpcode2(opcode, &limits); 438| 1|} _ZN4wabt11TypeChecker8OnBinaryENS_6OpcodeE: 440| 43.9k|Result TypeChecker::OnBinary(Opcode opcode) { 441| 43.9k| return CheckOpcode2(opcode); 442| 43.9k|} _ZN4wabt11TypeChecker7OnBlockERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEES8_: 445| 1.84k| const TypeVector& result_types) { 446| 1.84k| Result result = PopAndCheckSignature(param_types, "block"); 447| 1.84k| PushLabel(LabelType::Block, param_types, result_types); 448| 1.84k| PushTypes(param_types); 449| 1.84k| return result; 450| 1.84k|} _ZN4wabt11TypeChecker4OnBrEj: 452| 476|Result TypeChecker::OnBr(Index depth) { 453| 476| Result result = Result::Ok; 454| 476| Label* label; 455| 476| CHECK_RESULT(GetLabel(depth, &label)); ------------------ | | 55| 476| do { \ | | 56| 476| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 476] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 476| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 456| 476| result |= CheckSignature(label->br_types(), "br"); 457| 476| CHECK_RESULT(SetUnreachable()); ------------------ | | 55| 476| do { \ | | 56| 476| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 476] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 476| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 458| 476| return result; 459| 476|} _ZN4wabt11TypeChecker6OnBrIfEj: 461| 48|Result TypeChecker::OnBrIf(Index depth) { 462| 48| Result result = PopAndCheck1Type(Type::I32, "br_if"); 463| 48| Label* label; 464| 48| CHECK_RESULT(GetLabel(depth, &label)); ------------------ | | 55| 48| do { \ | | 56| 48| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 48] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 48| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 465| 48| result |= PopAndCheckSignature(label->br_types(), "br_if"); 466| 48| PushTypes(label->br_types()); 467| 48| return result; 468| 48|} _ZN4wabt11TypeChecker12BeginBrTableEv: 470| 1.35k|Result TypeChecker::BeginBrTable() { 471| 1.35k| br_table_sig_ = nullptr; 472| 1.35k| return PopAndCheck1Type(Type::I32, "br_table"); 473| 1.35k|} _ZN4wabt11TypeChecker15OnBrTableTargetEj: 475| 3.50k|Result TypeChecker::OnBrTableTarget(Index depth) { 476| 3.50k| Result result = Result::Ok; 477| 3.50k| Label* label; 478| 3.50k| CHECK_RESULT(GetLabel(depth, &label)); ------------------ | | 55| 3.50k| do { \ | | 56| 3.50k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 12, False: 3.49k] | | ------------------ | | 57| 12| return ::wabt::Result::Error; \ | | 58| 12| } \ | | 59| 3.50k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 479| 3.49k| TypeVector& label_sig = label->br_types(); 480| 3.49k| result |= CheckSignature(label_sig, "br_table"); 481| | 482| | // Make sure this label's signature is consistent with the previous labels' 483| | // signatures. 484| 3.49k| if (br_table_sig_ == nullptr) { ------------------ | Branch (484:7): [True: 1.35k, False: 2.14k] ------------------ 485| 1.35k| br_table_sig_ = &label_sig; 486| 2.14k| } else { 487| 2.14k| if (br_table_sig_->size() != label_sig.size()) { ------------------ | Branch (487:9): [True: 0, False: 2.14k] ------------------ 488| 0| result |= Result::Error; 489| 0| PrintError("br_table labels have inconsistent types: expected %s, got %s", 490| 0| TypesToString(*br_table_sig_).c_str(), 491| 0| TypesToString(label_sig).c_str()); 492| 0| } 493| 2.14k| } 494| | 495| 3.49k| return result; 496| 3.50k|} _ZN4wabt11TypeChecker10EndBrTableEv: 498| 1.34k|Result TypeChecker::EndBrTable() { 499| 1.34k| return SetUnreachable(); 500| 1.34k|} _ZN4wabt11TypeChecker6OnCallERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEES8_: 503| 643| const TypeVector& result_types) { 504| 643| return PopAndCheckCall(param_types, result_types, "call"); 505| 643|} _ZN4wabt11TypeChecker14OnCallIndirectERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEES8_RKNS_6LimitsE: 509| 338| const Limits& table_limits) { 510| 338| Result result = PopAndCheck1Type(table_limits.is_64 ? Type::I64 : Type::I32, ------------------ | Branch (510:36): [True: 0, False: 338] ------------------ 511| 338| "call_indirect"); 512| 338| result |= PopAndCheckCall(param_types, result_types, "call_indirect"); 513| 338| return result; 514| 338|} _ZN4wabt11TypeChecker12OnReturnCallERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEES8_: 537| 4| const TypeVector& result_types) { 538| 4| Result result = PopAndCheckSignature(param_types, "return_call"); 539| 4| Label* func_label; 540| 4| CHECK_RESULT(GetThisFunctionLabel(&func_label)); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 541| 4| result |= CheckReturnSignature(result_types, func_label->result_types, 542| 4| "return_call"); 543| | 544| 4| CHECK_RESULT(SetUnreachable()); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 545| 4| return result; 546| 4|} _ZN4wabt11TypeChecker20OnReturnCallIndirectERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEES8_: 549| 222| const TypeVector& result_types) { 550| 222| Result result = PopAndCheck1Type(Type::I32, "return_call_indirect"); 551| | 552| 222| result |= PopAndCheckSignature(param_types, "return_call_indirect"); 553| 222| Label* func_label; 554| 222| CHECK_RESULT(GetThisFunctionLabel(&func_label)); ------------------ | | 55| 222| do { \ | | 56| 222| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 222] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 222| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 555| 222| result |= CheckReturnSignature(result_types, func_label->result_types, 556| 222| "return_call_indirect"); 557| | 558| 222| CHECK_RESULT(SetUnreachable()); ------------------ | | 55| 222| do { \ | | 56| 222| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 222] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 222| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 559| 222| return result; 560| 222|} _ZN4wabt11TypeChecker9OnCompareENS_6OpcodeE: 562| 12.0k|Result TypeChecker::OnCompare(Opcode opcode) { 563| 12.0k| return CheckOpcode2(opcode); 564| 12.0k|} _ZN4wabt11TypeChecker7OnCatchERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEE: 566| 4|Result TypeChecker::OnCatch(const TypeVector& sig) { 567| 4| Result result = Result::Ok; 568| 4| Label* label; 569| 4| CHECK_RESULT(TopLabel(&label)); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 4] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 570| 4| result |= Check2LabelTypes(label, LabelType::Try, LabelType::Catch); 571| 4| result |= PopAndCheckSignature(label->result_types, "try block"); 572| 4| result |= CheckTypeStackEnd("try block"); 573| 4| ResetTypeStackToLabel(label); 574| 4| label->label_type = LabelType::Catch; 575| 4| label->unreachable = false; 576| 4| PushTypes(sig); 577| 4| return result; 578| 4|} _ZN4wabt11TypeChecker7OnConstENS_4TypeE: 580| 26.6k|Result TypeChecker::OnConst(Type type) { 581| 26.6k| PushType(type); 582| 26.6k| return Result::Ok; 583| 26.6k|} _ZN4wabt11TypeChecker9OnConvertENS_6OpcodeE: 585| 19.8k|Result TypeChecker::OnConvert(Opcode opcode) { 586| 19.8k| return CheckOpcode1(opcode); 587| 19.8k|} _ZN4wabt11TypeChecker6OnDropEv: 610| 94|Result TypeChecker::OnDrop() { 611| 94| Result result = Result::Ok; 612| 94| result |= DropTypes(1); 613| 94| PrintStackIfFailed(result, "drop", Type::Any); 614| 94| return result; 615| 94|} _ZN4wabt11TypeChecker6OnElseEv: 617| 278|Result TypeChecker::OnElse() { 618| 278| Result result = Result::Ok; 619| 278| Label* label; 620| 278| CHECK_RESULT(TopLabel(&label)); ------------------ | | 55| 278| do { \ | | 56| 278| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 278] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 278| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 621| 278| result |= CheckLabelType(label, LabelType::If); 622| 278| result |= PopAndCheckSignature(label->result_types, "`if true` branch"); 623| 278| result |= CheckTypeStackEnd("`if true` branch"); 624| 278| ResetTypeStackToLabel(label); 625| 278| PushTypes(label->param_types); 626| 278| label->label_type = LabelType::Else; 627| 278| label->unreachable = false; 628| 278| return result; 629| 278|} _ZN4wabt11TypeChecker5OnEndEPNS0_5LabelEPKcS4_: 633| 2.91k| const char* end_desc) { 634| 2.91k| Result result = Result::Ok; 635| 2.91k| result |= PopAndCheckSignature(label->result_types, sig_desc); 636| 2.91k| result |= CheckTypeStackEnd(end_desc); 637| 2.91k| ResetTypeStackToLabel(label); 638| 2.91k| PushTypes(label->result_types); 639| 2.91k| PopLabel(); 640| 2.91k| return result; 641| 2.91k|} _ZN4wabt11TypeChecker5OnEndEv: 643| 776|Result TypeChecker::OnEnd() { 644| 776| Result result = Result::Ok; 645| 776| static const char* s_label_type_name[] = { 646| 776| "function", "initializer expression", "block", "loop", 647| 776| "if", "`if false` branch", "try", "try catch"}; 648| 776| WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_label_type_name) == kLabelTypeCount); ------------------ | | 89| 776|#define WABT_STATIC_ASSERT(x) static_assert((x), #x) ------------------ 649| 776| Label* label; 650| 776| CHECK_RESULT(TopLabel(&label)); ------------------ | | 55| 776| do { \ | | 56| 776| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 776] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 776| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 651| 776| assert(static_cast(label->label_type) < kLabelTypeCount); 652| 776| if (label->label_type == LabelType::If) { ------------------ | Branch (652:7): [True: 95, False: 681] ------------------ 653| | // An if without an else will just pass the params through, so the result 654| | // types must be the same as the param types. It has the same behavior as 655| | // an empty else block. 656| 95| CHECK_RESULT(OnElse()); ------------------ | | 55| 95| do { \ | | 56| 95| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 1, False: 94] | | ------------------ | | 57| 1| return ::wabt::Result::Error; \ | | 58| 1| } \ | | 59| 95| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 657| 95| } 658| | 659| 775| const char* desc = s_label_type_name[static_cast(label->label_type)]; 660| 775| result |= OnEnd(label, desc, desc); 661| 775| return result; 662| 776|} _ZN4wabt11TypeChecker4OnIfERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEES8_: 665| 552| const TypeVector& result_types) { 666| 552| Result result = PopAndCheck1Type(Type::I32, "if"); 667| 552| result |= PopAndCheckSignature(param_types, "if"); 668| 552| PushLabel(LabelType::If, param_types, result_types); 669| 552| PushTypes(param_types); 670| 552| return result; 671| 552|} _ZN4wabt11TypeChecker11OnGlobalGetENS_4TypeE: 673| 197|Result TypeChecker::OnGlobalGet(Type type) { 674| 197| PushType(type); 675| 197| return Result::Ok; 676| 197|} _ZN4wabt11TypeChecker11OnGlobalSetENS_4TypeE: 678| 33|Result TypeChecker::OnGlobalSet(Type type) { 679| 33| return PopAndCheck1Type(type, "global.set"); 680| 33|} _ZN4wabt11TypeChecker6OnLoadENS_6OpcodeERKNS_6LimitsE: 682| 5.02k|Result TypeChecker::OnLoad(Opcode opcode, const Limits& limits) { 683| 5.02k| return CheckOpcode1(opcode, &limits); 684| 5.02k|} _ZN4wabt11TypeChecker10OnLocalGetENS_4TypeE: 686| 1.94k|Result TypeChecker::OnLocalGet(Type type) { 687| 1.94k| PushType(type); 688| 1.94k| return Result::Ok; 689| 1.94k|} _ZN4wabt11TypeChecker10OnLocalSetENS_4TypeE: 691| 729|Result TypeChecker::OnLocalSet(Type type) { 692| 729| return PopAndCheck1Type(type, "local.set"); 693| 729|} _ZN4wabt11TypeChecker10OnLocalTeeENS_4TypeE: 695| 47|Result TypeChecker::OnLocalTee(Type type) { 696| 47| Result result = Result::Ok; 697| 47| result |= PopAndCheck1Type(type, "local.tee"); 698| 47| PushType(type); 699| 47| return result; 700| 47|} _ZN4wabt11TypeChecker6OnLoopERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEES8_: 703| 602| const TypeVector& result_types) { 704| 602| Result result = PopAndCheckSignature(param_types, "loop"); 705| 602| PushLabel(LabelType::Loop, param_types, result_types); 706| 602| PushTypes(param_types); 707| 602| return result; 708| 602|} _ZN4wabt11TypeChecker10OnDataDropEj: 722| 1|Result TypeChecker::OnDataDrop(uint32_t segment) { 723| 1| return Result::Ok; 724| 1|} _ZN4wabt11TypeChecker12OnMemoryFillERKNS_6LimitsE: 726| 297|Result TypeChecker::OnMemoryFill(const Limits& limits) { 727| 297| return CheckOpcode3(Opcode::MemoryFill, &limits, nullptr, &limits); 728| 297|} _ZN4wabt11TypeChecker12OnMemoryGrowERKNS_6LimitsE: 730| 94|Result TypeChecker::OnMemoryGrow(const Limits& limits) { 731| 94| Result result = PopAndCheck1Type(limits.IndexType(), "memory.grow"); 732| 94| PushType(limits.IndexType()); 733| 94| return result; 734| 94|} _ZN4wabt11TypeChecker12OnMemorySizeERKNS_6LimitsE: 740| 4|Result TypeChecker::OnMemorySize(const Limits& limits) { 741| 4| PushType(limits.IndexType()); 742| 4| return Result::Ok; 743| 4|} _ZN4wabt11TypeChecker11OnTableCopyERKNS_6LimitsES3_: 746| 53| const Limits& src_limits) { 747| 53| Limits size_limits = src_limits; 748| | // The memory64 proposal specifies that the type of the size argument should 749| | // be the mimimum of the two table types. 750| 53| if (src_limits.is_64 && !dst_limits.is_64) { ------------------ | Branch (750:7): [True: 0, False: 53] | Branch (750:27): [True: 0, False: 0] ------------------ 751| 0| size_limits = dst_limits; 752| 0| } 753| 53| return CheckOpcode3(Opcode::TableCopy, &dst_limits, &src_limits, 754| 53| &size_limits); 755| 53|} _ZN4wabt11TypeChecker10OnTableGetENS_4TypeERKNS_6LimitsE: 765| 50|Result TypeChecker::OnTableGet(Type elem_type, const Limits& limits) { 766| 50| Result result = CheckOpcode1(Opcode::TableGet, &limits); 767| 50| PushType(elem_type); 768| 50| return result; 769| 50|} _ZN4wabt11TypeChecker10OnTableSetENS_4TypeERKNS_6LimitsE: 771| 94|Result TypeChecker::OnTableSet(Type elem_type, const Limits& limits) { 772| 94| return PopAndCheck2Types(limits.IndexType(), elem_type, "table.set"); 773| 94|} _ZN4wabt11TypeChecker11OnTableFillENS_4TypeERKNS_6LimitsE: 787| 65|Result TypeChecker::OnTableFill(Type elem_type, const Limits& limits) { 788| 65| return PopAndCheck3Types(limits.IndexType(), elem_type, limits.IndexType(), 789| 65| "table.fill"); 790| 65|} _ZN4wabt11TypeChecker13OnRefFuncExprEjb: 792| 89|Result TypeChecker::OnRefFuncExpr(Index func_type, bool force_generic_funcref) { 793| | /* 794| | * In a const expression, treat ref.func as producing a generic funcref. 795| | * This avoids having to implement funcref subtyping (for now) and matches 796| | * the previous behavior where SharedValidator::OnElemSegmentElemExpr_RefFunc 797| | * examined only the validity of the function index. 798| | */ 799| 89| if (features_.function_references_enabled() && !force_generic_funcref) { ------------------ | Branch (799:7): [True: 49, False: 40] | Branch (799:50): [True: 7, False: 42] ------------------ 800| 7| PushType(Type(Type::Reference, func_type)); 801| 82| } else { 802| 82| PushType(Type::FuncRef); 803| 82| } 804| 89| return Result::Ok; 805| 89|} _ZN4wabt11TypeChecker13OnRefNullExprENS_4TypeE: 807| 27|Result TypeChecker::OnRefNullExpr(Type type) { 808| 27| PushType(type); 809| 27| return Result::Ok; 810| 27|} _ZN4wabt11TypeChecker15OnRefIsNullExprEv: 812| 34|Result TypeChecker::OnRefIsNullExpr() { 813| 34| Type type; 814| 34| Result result = PeekType(0, &type); 815| 34| if (!(type == Type::Any || type.IsRef())) { ------------------ | Branch (815:9): [True: 32, False: 2] | Branch (815:30): [True: 2, False: 0] ------------------ 816| 0| TypeVector actual; 817| 0| if (Succeeded(result)) { ------------------ | Branch (817:9): [True: 0, False: 0] ------------------ 818| 0| actual.push_back(type); 819| 0| } 820| 0| std::string message = 821| 0| "type mismatch in ref.is_null, expected reference but got " + 822| 0| TypesToString(actual); 823| 0| PrintError("%s", message.c_str()); 824| 0| result = Result::Error; 825| 0| } 826| 34| result |= DropTypes(1); 827| 34| PushType(Type::I32); 828| 34| return result; 829| 34|} _ZN4wabt11TypeChecker9OnRethrowEj: 831| 4|Result TypeChecker::OnRethrow(Index depth) { 832| 4| Result result = Result::Ok; 833| 4| Label* label; 834| 4| CHECK_RESULT(GetRethrowLabel(depth, &label)); ------------------ | | 55| 4| do { \ | | 56| 4| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 4, False: 0] | | ------------------ | | 57| 4| return ::wabt::Result::Error; \ | | 58| 4| } \ | | 59| 4| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 835| 0| CHECK_RESULT(SetUnreachable()); ------------------ | | 55| 0| do { \ | | 56| 0| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 0] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 0| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 836| 0| return result; 837| 0|} _ZN4wabt11TypeChecker7OnThrowERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEE: 839| 1|Result TypeChecker::OnThrow(const TypeVector& sig) { 840| 1| Result result = Result::Ok; 841| 1| result |= PopAndCheckSignature(sig, "throw"); 842| 1| CHECK_RESULT(SetUnreachable()); ------------------ | | 55| 1| do { \ | | 56| 1| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 843| 1| return result; 844| 1|} _ZN4wabt11TypeChecker8OnReturnEv: 846| 1.72k|Result TypeChecker::OnReturn() { 847| 1.72k| Result result = Result::Ok; 848| 1.72k| Label* func_label; 849| 1.72k| CHECK_RESULT(GetThisFunctionLabel(&func_label)); ------------------ | | 55| 1.72k| do { \ | | 56| 1.72k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.72k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.72k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 850| 1.72k| result |= PopAndCheckSignature(func_label->result_types, "return"); 851| 1.72k| CHECK_RESULT(SetUnreachable()); ------------------ | | 55| 1.72k| do { \ | | 56| 1.72k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.72k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.72k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 852| 1.72k| return result; 853| 1.72k|} _ZN4wabt11TypeChecker8OnSelectERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEE: 855| 966|Result TypeChecker::OnSelect(const TypeVector& expected) { 856| 966| Result result = Result::Ok; 857| 966| Type type1 = Type::Any; 858| 966| Type type2 = Type::Any; 859| 966| Type result_type = Type::Any; 860| 966| result |= PeekAndCheckType(0, Type::I32); 861| 966| result |= PeekType(1, &type1); 862| 966| result |= PeekType(2, &type2); 863| 966| if (expected.empty()) { ------------------ | Branch (863:7): [True: 916, False: 50] ------------------ 864| 916| if (type1.IsRef() || type2.IsRef()) { ------------------ | Branch (864:9): [True: 0, False: 916] | Branch (864:26): [True: 0, False: 916] ------------------ 865| 0| result = Result::Error; 866| 916| } else { 867| 916| result |= CheckType(type1, type2); 868| 916| result_type = type1; 869| 916| } 870| 916| } else { 871| 50| assert(expected.size() == 1); 872| 50| result |= CheckType(type1, expected[0]); 873| 50| result |= CheckType(type2, expected[0]); 874| 50| } 875| 966| PrintStackIfFailed(result, "select", result_type, result_type, Type::I32); 876| 966| result |= DropTypes(3); 877| 966| PushType(result_type); 878| 966| return result; 879| 966|} _ZN4wabt11TypeChecker7OnStoreENS_6OpcodeERKNS_6LimitsE: 881| 333|Result TypeChecker::OnStore(Opcode opcode, const Limits& limits) { 882| 333| return CheckOpcode2(opcode, &limits); 883| 333|} _ZN4wabt11TypeChecker5OnTryERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEES8_: 886| 1| const TypeVector& result_types) { 887| 1| Result result = PopAndCheckSignature(param_types, "try"); 888| 1| PushLabel(LabelType::Try, param_types, result_types); 889| 1| PushTypes(param_types); 890| 1| return result; 891| 1|} _ZN4wabt11TypeChecker7OnUnaryENS_6OpcodeE: 893| 33.4k|Result TypeChecker::OnUnary(Opcode opcode) { 894| 33.4k| return CheckOpcode1(opcode); 895| 33.4k|} _ZN4wabt11TypeChecker12OnSimdLaneOpENS_6OpcodeEm: 901| 1.02k|Result TypeChecker::OnSimdLaneOp(Opcode opcode, uint64_t lane_idx) { 902| 1.02k| Result result = Result::Ok; 903| 1.02k| uint32_t lane_count = opcode.GetSimdLaneCount(); 904| 1.02k| if (lane_idx >= lane_count) { ------------------ | Branch (904:7): [True: 2, False: 1.02k] ------------------ 905| 2| PrintError("lane index must be less than %d (got %" PRIu64 ")", lane_count, 906| 2| lane_idx); 907| 2| result = Result::Error; 908| 2| } 909| | 910| 1.02k| switch (opcode) { 911| 4| case Opcode::I8X16ExtractLaneS: ------------------ | Branch (911:5): [True: 4, False: 1.02k] ------------------ 912| 4| case Opcode::I8X16ExtractLaneU: ------------------ | Branch (912:5): [True: 0, False: 1.02k] ------------------ 913| 5| case Opcode::I16X8ExtractLaneS: ------------------ | Branch (913:5): [True: 1, False: 1.02k] ------------------ 914| 186| case Opcode::I16X8ExtractLaneU: ------------------ | Branch (914:5): [True: 181, False: 844] ------------------ 915| 186| case Opcode::I32X4ExtractLane: ------------------ | Branch (915:5): [True: 0, False: 1.02k] ------------------ 916| 186| case Opcode::F32X4ExtractLane: ------------------ | Branch (916:5): [True: 0, False: 1.02k] ------------------ 917| 439| case Opcode::I64X2ExtractLane: ------------------ | Branch (917:5): [True: 253, False: 772] ------------------ 918| 644| case Opcode::F64X2ExtractLane: ------------------ | Branch (918:5): [True: 205, False: 820] ------------------ 919| 644| result |= CheckOpcode1(opcode); 920| 644| break; 921| 92| case Opcode::I8X16ReplaceLane: ------------------ | Branch (921:5): [True: 92, False: 933] ------------------ 922| 376| case Opcode::I16X8ReplaceLane: ------------------ | Branch (922:5): [True: 284, False: 741] ------------------ 923| 376| case Opcode::I32X4ReplaceLane: ------------------ | Branch (923:5): [True: 0, False: 1.02k] ------------------ 924| 381| case Opcode::F32X4ReplaceLane: ------------------ | Branch (924:5): [True: 5, False: 1.02k] ------------------ 925| 381| case Opcode::I64X2ReplaceLane: ------------------ | Branch (925:5): [True: 0, False: 1.02k] ------------------ 926| 381| case Opcode::F64X2ReplaceLane: ------------------ | Branch (926:5): [True: 0, False: 1.02k] ------------------ 927| 381| result |= CheckOpcode2(opcode); 928| 381| break; 929| 0| default: ------------------ | Branch (929:5): [True: 0, False: 1.02k] ------------------ 930| 0| WABT_UNREACHABLE; ------------------ | | 112| 0|#define WABT_UNREACHABLE abort() ------------------ 931| 1.02k| } 932| 1.02k| return result; 933| 1.02k|} _ZN4wabt11TypeChecker14OnSimdLoadLaneENS_6OpcodeERKNS_6LimitsEm: 937| 169| uint64_t lane_idx) { 938| 169| Result result = Result::Ok; 939| 169| uint32_t lane_count = opcode.GetSimdLaneCount(); 940| 169| if (lane_idx >= lane_count) { ------------------ | Branch (940:7): [True: 1, False: 168] ------------------ 941| 1| PrintError("lane index must be less than %d (got %" PRIu64 ")", lane_count, 942| 1| lane_idx); 943| 1| result = Result::Error; 944| 1| } 945| 169| result |= CheckOpcode2(opcode, &limits); 946| 169| return result; 947| 169|} _ZN4wabt11TypeChecker15OnSimdStoreLaneENS_6OpcodeERKNS_6LimitsEm: 951| 201| uint64_t lane_idx) { 952| 201| Result result = Result::Ok; 953| 201| uint32_t lane_count = opcode.GetSimdLaneCount(); 954| 201| if (lane_idx >= lane_count) { ------------------ | Branch (954:7): [True: 0, False: 201] ------------------ 955| 0| PrintError("lane index must be less than %d (got %" PRIu64 ")", lane_count, 956| 0| lane_idx); 957| 0| result = Result::Error; 958| 0| } 959| 201| result |= CheckOpcode2(opcode, &limits); 960| 201| return result; 961| 201|} _ZN4wabt11TypeChecker15OnSimdShuffleOpENS_6OpcodeE4v128: 963| 4|Result TypeChecker::OnSimdShuffleOp(Opcode opcode, v128 lane_idx) { 964| 4| Result result = Result::Ok; 965| 4| uint8_t simd_data[16]; 966| 4| memcpy(simd_data, &lane_idx, 16); 967| 68| for (int i = 0; i < 16; i++) { ------------------ | Branch (967:19): [True: 64, False: 4] ------------------ 968| 64| if (simd_data[i] >= 32) { ------------------ | Branch (968:9): [True: 64, False: 0] ------------------ 969| 64| PrintError("lane index must be less than 32 (got %d)", simd_data[i]); 970| 64| result = Result::Error; 971| 64| } 972| 64| } 973| | 974| 4| result |= CheckOpcode2(opcode); 975| 4| return result; 976| 4|} _ZN4wabt11TypeChecker13OnUnreachableEv: 978| 188k|Result TypeChecker::OnUnreachable() { 979| 188k| return SetUnreachable(); 980| 188k|} _ZN4wabt11TypeChecker11EndFunctionEv: 982| 1.85k|Result TypeChecker::EndFunction() { 983| 1.85k| Result result = Result::Ok; 984| 1.85k| Label* label; 985| 1.85k| CHECK_RESULT(TopLabel(&label)); ------------------ | | 55| 1.85k| do { \ | | 56| 1.85k| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 1.85k] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 1.85k| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 986| 1.85k| result |= CheckLabelType(label, LabelType::Func); 987| 1.85k| result |= OnEnd(label, "implicit return", "function"); 988| 1.85k| return result; 989| 1.85k|} _ZN4wabt11TypeChecker13BeginInitExprENS_4TypeE: 991| 320|Result TypeChecker::BeginInitExpr(Type type) { 992| 320| type_stack_.clear(); 993| 320| label_stack_.clear(); 994| 320| PushLabel(LabelType::InitExpr, TypeVector(), {type}); 995| 320| return Result::Ok; 996| 320|} _ZN4wabt11TypeChecker11EndInitExprEv: 998| 281|Result TypeChecker::EndInitExpr() { 999| 281| Result result = Result::Ok; 1000| 281| Label* label; 1001| 281| CHECK_RESULT(TopLabel(&label)); ------------------ | | 55| 281| do { \ | | 56| 281| if (Failed(expr)) { \ | | ------------------ | | | Branch (56:9): [True: 0, False: 281] | | ------------------ | | 57| 0| return ::wabt::Result::Error; \ | | 58| 0| } \ | | 59| 281| } while (0) | | ------------------ | | | Branch (59:12): [Folded - Ignored] | | ------------------ ------------------ 1002| 281| result |= CheckLabelType(label, LabelType::InitExpr); 1003| 281| result |= OnEnd(label, "initializer expression", "initializer expression"); 1004| 281| return result; 1005| 281|} type-checker.cc:_ZN4wabt12_GLOBAL__N_113TypesToStringERKNSt3__16vectorINS_4TypeENS1_9allocatorIS3_EEEEPKc: 26| 238| const char* prefix = nullptr) { 27| 238| std::string result = "["; 28| 238| if (prefix) { ------------------ | Branch (28:7): [True: 23, False: 215] ------------------ 29| 23| result += prefix; 30| 23| } 31| | 32| 538| for (size_t i = 0; i < types.size(); ++i) { ------------------ | Branch (32:22): [True: 300, False: 238] ------------------ 33| 300| result += types[i].GetName(); 34| 300| if (i < types.size() - 1) { ------------------ | Branch (34:9): [True: 97, False: 203] ------------------ 35| 97| result += ", "; 36| 97| } 37| 300| } 38| 238| result += "]"; 39| 238| return result; 40| 238|} type-checker.cc:_ZN4wabtL14GetMemoryParamENS_4TypeEPKNS_6LimitsE: 322| 117k|static Type GetMemoryParam(Type param, const Limits* limits) { 323| 117k| return limits ? limits->IndexType() : param; ------------------ | Branch (323:10): [True: 6.55k, False: 110k] ------------------ 324| 117k|} _ZN4wabt11IsValidUtf8EPKcm: 54| 203k|bool IsValidUtf8(const char* s, size_t s_length) { 55| 203k| const uint8_t* p = reinterpret_cast(s); 56| 203k| const uint8_t* end = p + s_length; 57| 837k| while (p < end) { ------------------ | Branch (57:10): [True: 638k, False: 198k] ------------------ 58| 638k| uint8_t cu0 = *p; 59| 638k| int length = s_utf8_length[cu0]; 60| 638k| if (p + length > end) { ------------------ | Branch (60:9): [True: 251, False: 638k] ------------------ 61| 251| return false; 62| 251| } 63| | 64| 638k| switch (length) { ------------------ | Branch (64:13): [True: 0, False: 638k] ------------------ 65| 3.36k| case 0: ------------------ | Branch (65:7): [True: 3.36k, False: 635k] ------------------ 66| 3.36k| return false; 67| | 68| 631k| case 1: ------------------ | Branch (68:7): [True: 631k, False: 7.11k] ------------------ 69| 631k| p++; 70| 631k| break; 71| | 72| 1.06k| case 2: ------------------ | Branch (72:7): [True: 1.06k, False: 637k] ------------------ 73| 1.06k| p++; 74| 1.06k| if (!IsCont(*p++)) { ------------------ | Branch (74:13): [True: 78, False: 983] ------------------ 75| 78| return false; 76| 78| } 77| 983| break; 78| | 79| 1.57k| case 3: { ------------------ | Branch (79:7): [True: 1.57k, False: 636k] ------------------ 80| 1.57k| p++; 81| 1.57k| uint8_t cu1 = *p++; 82| 1.57k| uint8_t cu2 = *p++; 83| 1.57k| if (!(IsCont(cu1) && IsCont(cu2)) || ------------------ | Branch (83:15): [True: 1.55k, False: 25] | Branch (83:30): [True: 1.39k, False: 157] ------------------ 84| 1.57k| (cu0 == 0xe0 && cu1 < 0xa0) || // Overlong encoding. ------------------ | Branch (84:14): [True: 447, False: 949] | Branch (84:29): [True: 401, False: 46] ------------------ 85| 1.57k| (cu0 == 0xed && cu1 >= 0xa0)) // UTF-16 surrogate halves. ------------------ | Branch (85:14): [True: 210, False: 785] | Branch (85:29): [True: 0, False: 210] ------------------ 86| 583| return false; 87| 995| break; 88| 1.57k| } 89| | 90| 1.10k| case 4: { ------------------ | Branch (90:7): [True: 1.10k, False: 637k] ------------------ 91| 1.10k| p++; 92| 1.10k| uint8_t cu1 = *p++; 93| 1.10k| uint8_t cu2 = *p++; 94| 1.10k| uint8_t cu3 = *p++; 95| 1.10k| if (!(IsCont(cu1) && IsCont(cu2) && IsCont(cu3)) || ------------------ | Branch (95:15): [True: 1.03k, False: 70] | Branch (95:30): [True: 893, False: 146] | Branch (95:45): [True: 765, False: 128] ------------------ 96| 1.10k| (cu0 == 0xf0 && cu1 < 0x90) || // Overlong encoding. ------------------ | Branch (96:14): [True: 234, False: 531] | Branch (96:29): [True: 0, False: 234] ------------------ 97| 1.10k| (cu0 == 0xf4 && cu1 >= 0x90)) // Code point >= 0x11000. ------------------ | Branch (97:14): [True: 383, False: 382] | Branch (97:29): [True: 0, False: 383] ------------------ 98| 344| return false; 99| 765| break; 100| 1.10k| } 101| 638k| } 102| 638k| } 103| 198k| return true; 104| 203k|} utf8.cc:_ZN4wabt12_GLOBAL__N_16IsContEh: 48| 7.23k|bool IsCont(uint8_t c) { 49| 7.23k| return (c & 0xc0) == 0x80; 50| 7.23k|}