Coverage Report

Created: 2026-11-12 06:35

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/WasmEdge/lib/loader/ast/component/component_instance.cpp
Line
Count
Source
1
// SPDX-License-Identifier: Apache-2.0
2
// SPDX-FileCopyrightText: Copyright The WasmEdge Authors
3
4
#include "loader/loader.h"
5
6
namespace WasmEdge {
7
namespace Loader {
8
9
148k
Expect<void> Loader::loadInstance(AST::Component::CoreInstance &Instance) {
10
148k
  auto ReportError = [this](auto E) {
11
31
    return logLoadError(E, FMgr.getLastOffset(),
12
31
                        ASTNodeAttr::Comp_CoreInstance);
13
31
  };
14
  // core:instance       ::= ie:<core:instanceexpr>
15
  //                       => (instance ie)
16
  // core:instanceexpr   ::= 0x00 m:<moduleidx> arg*:vec(<core:instantiatearg>)
17
  //                       => (instantiate m arg*)
18
  //                       | 0x01 e*:vec(<core:inlineexport>)
19
  //                       => e*
20
21
148k
  auto LoadInstArg =
22
148k
      [this](AST::Component::InstantiateArg<uint32_t> &Arg) -> Expect<void> {
23
641
    auto ReportArgError = [this](auto E) {
24
53
      return logLoadError(E, FMgr.getLastOffset(),
25
53
                          ASTNodeAttr::Comp_CoreInstanceArg);
26
53
    };
component_instance.cpp:auto WasmEdge::Loader::Loader::loadInstance(WasmEdge::AST::Component::CoreInstance&)::$_0::operator()(WasmEdge::AST::Component::InstantiateArg<unsigned int>&) const::{lambda(auto:1)#1}::operator()<WasmEdge::ErrCode>(WasmEdge::ErrCode) const
Line
Count
Source
23
27
    auto ReportArgError = [this](auto E) {
24
27
      return logLoadError(E, FMgr.getLastOffset(),
25
27
                          ASTNodeAttr::Comp_CoreInstanceArg);
26
27
    };
component_instance.cpp:auto WasmEdge::Loader::Loader::loadInstance(WasmEdge::AST::Component::CoreInstance&)::$_0::operator()(WasmEdge::AST::Component::InstantiateArg<unsigned int>&) const::{lambda(auto:1)#1}::operator()<WasmEdge::ErrCode::Value>(WasmEdge::ErrCode::Value) const
Line
Count
Source
23
26
    auto ReportArgError = [this](auto E) {
24
26
      return logLoadError(E, FMgr.getLastOffset(),
25
26
                          ASTNodeAttr::Comp_CoreInstanceArg);
26
26
    };
27
    // core:instantiatearg ::= n:<core:name> 0x12 i:<instanceidx>
28
    //                       => (with n (instance i))
29
641
    EXPECTED_TRY(Arg.getName(), FMgr.readName().map_error(ReportArgError));
30
625
    EXPECTED_TRY(uint8_t B, FMgr.readByte().map_error(ReportArgError));
31
616
    if (B != 0x12U) {
32
26
      return ReportArgError(ErrCode::Value::MalformedCoreInstance);
33
26
    }
34
590
    EXPECTED_TRY(Arg.getIndex(), FMgr.readU32().map_error(ReportArgError));
35
588
    return {};
36
590
  };
37
38
148k
  auto LoadInlineExp =
39
148k
      [this](AST::Component::InlineExport &Exp) -> Expect<void> {
40
    // core:inlineexport ::= n:<core:name> si:<core:sortidx> => (export n si)
41
6.07k
    EXPECTED_TRY(Exp.getName(), FMgr.readName().map_error([this](auto E) {
42
6.04k
      return logLoadError(E, FMgr.getLastOffset(),
43
6.04k
                          ASTNodeAttr::Comp_CoreInlineExport);
44
6.04k
    }));
45
6.04k
    return loadSortIndex(Exp.getSortIdx(), true).map_error([](auto E) {
46
53
      spdlog::error(ErrInfo::InfoAST(ASTNodeAttr::Comp_CoreInlineExport));
47
53
      return E;
48
53
    });
49
6.07k
  };
50
51
148k
  EXPECTED_TRY(uint8_t Flag, FMgr.readByte().map_error(ReportError));
52
148k
  switch (Flag) {
53
65.6k
  case 0x00: {
54
65.6k
    EXPECTED_TRY(uint32_t Idx, FMgr.readU32().map_error(ReportError));
55
65.6k
    std::vector<AST::Component::InstantiateArg<uint32_t>> Args;
56
65.6k
    EXPECTED_TRY(loadVec<AST::Component::CoreInstance>(Args, LoadInstArg));
57
65.5k
    Instance.setInstantiateArgs(Idx, std::move(Args));
58
65.5k
    return {};
59
65.6k
  }
60
82.6k
  case 0x01: {
61
82.6k
    std::vector<AST::Component::InlineExport> Exports;
62
82.6k
    EXPECTED_TRY(loadVec<AST::Component::CoreInstance>(Exports, LoadInlineExp));
63
82.5k
    Instance.setInlineExports(std::move(Exports));
64
82.5k
    return {};
65
82.6k
  }
66
22
  default:
67
22
    return logLoadError(ErrCode::Value::MalformedCoreInstance,
68
22
                        FMgr.getLastOffset(), ASTNodeAttr::Comp_CoreInstance);
69
148k
  }
70
148k
}
71
72
2.24M
Expect<void> Loader::loadInstance(AST::Component::Instance &Instance) {
73
2.24M
  auto ReportError = [this](auto E) {
74
28
    return logLoadError(E, FMgr.getLastOffset(), ASTNodeAttr::Comp_Instance);
75
28
  };
76
  // instance     ::= ie:<instanceexpr>
77
  //                => (instance ie)
78
  // instanceexpr ::= 0x00 c:<componentidx> arg*:vec(<instantiatearg>)
79
  //                => (instantiate c arg*)
80
  //                | 0x01 e*:vec(<inlineexport>)
81
  //                => e*
82
83
2.24M
  auto LoadInstArg =
84
2.24M
      [this](AST::Component::InstantiateArg<AST::Component::SortIndex> &Arg)
85
2.24M
      -> Expect<void> {
86
    // instantiatearg ::= n:<string> si:<sortidx> => (with n si)
87
65.4k
    EXPECTED_TRY(Arg.getName(), FMgr.readName().map_error([this](auto E) {
88
65.4k
      return logLoadError(E, FMgr.getLastOffset(),
89
65.4k
                          ASTNodeAttr::Comp_InstanceArg);
90
65.4k
    }));
91
65.4k
    return loadSortIndex(Arg.getIndex()).map_error([](auto E) {
92
46
      spdlog::error(ErrInfo::InfoAST(ASTNodeAttr::Comp_InstanceArg));
93
46
      return E;
94
46
    });
95
65.4k
  };
96
97
2.24M
  auto LoadInlineExp =
98
2.24M
      [this](AST::Component::InlineExport &Exp) -> Expect<void> {
99
    // inlineexport ::= na:<nameattributes> si:<sortidx> => (export na si)
100
2.63k
    EXPECTED_TRY(loadNameAttributes(Exp.getName(), Exp.getImplements(),
101
2.58k
                                    Exp.getExternalIds(),
102
2.58k
                                    Exp.getVersionSuffixes())
103
2.58k
                     .map_error([this](auto E) {
104
2.58k
                       return logLoadError(E, FMgr.getLastOffset(),
105
2.58k
                                           ASTNodeAttr::Comp_InlineExport);
106
2.58k
                     }));
107
2.58k
    return loadSortIndex(Exp.getSortIdx()).map_error([](auto E) {
108
23
      spdlog::error(ErrInfo::InfoAST(ASTNodeAttr::Comp_InlineExport));
109
23
      return E;
110
23
    });
111
2.63k
  };
112
113
2.24M
  EXPECTED_TRY(uint8_t Flag, FMgr.readByte().map_error(ReportError));
114
2.24M
  switch (Flag) {
115
1.20M
  case 0x00: {
116
1.20M
    EXPECTED_TRY(uint32_t Idx, FMgr.readU32().map_error(ReportError));
117
1.20M
    std::vector<AST::Component::InstantiateArg<AST::Component::SortIndex>> Args;
118
1.20M
    EXPECTED_TRY(loadVec<AST::Component::Instance>(Args, LoadInstArg));
119
1.20M
    Instance.setInstantiateArgs(Idx, std::move(Args));
120
1.20M
    return {};
121
1.20M
  }
122
1.03M
  case 0x01: {
123
1.03M
    std::vector<AST::Component::InlineExport> Exports;
124
1.03M
    EXPECTED_TRY(loadVec<AST::Component::Instance>(Exports, LoadInlineExp));
125
1.03M
    Instance.setInlineExports(std::move(Exports));
126
1.03M
    return {};
127
1.03M
  }
128
30
  default:
129
30
    return logLoadError(ErrCode::Value::MalformedInstance, FMgr.getLastOffset(),
130
30
                        ASTNodeAttr::Comp_Instance);
131
2.24M
  }
132
2.24M
}
133
134
} // namespace Loader
135
} // namespace WasmEdge