/src/WasmEdge/lib/loader/ast/description.cpp

Source
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2019-2024 Second State INC

#include "loader/loader.h"

namespace WasmEdge {
namespace Loader {

// Load binary of Import description. See "include/loader/loader.h".
Expect<void> Loader::loadDesc(AST::ImportDesc &ImpDesc) {
  auto ReportError = [this](auto E) {
    return logLoadError(E, FMgr.getLastOffset(), ASTNodeAttr::Desc_Import);
  };

  // Read the module name.
  EXPECTED_TRY(FMgr.readName().map_error(ReportError).map([&](std::string S) {
    ImpDesc.setModuleName(S);
  }));

  // Read the external name.
  EXPECTED_TRY(FMgr.readName().map_error(ReportError).map([&](std::string S) {
    ImpDesc.setExternalName(S);
  }));

  // Read the external type.
  EXPECTED_TRY(FMgr.readByte().map_error(ReportError).map([&](uint8_t B) {
    ImpDesc.setExternalType(static_cast<ExternalType>(B));
  }));

  // Make content node according to external type.
  switch (ImpDesc.getExternalType()) {
  case ExternalType::Function: {
    // Read the function type index.
    EXPECTED_TRY(FMgr.readU32().map_error(ReportError).map([&](uint32_t Idx) {
      ImpDesc.setExternalFuncTypeIdx(Idx);
    }));
    return {};
  }
  case ExternalType::Table: {
    // Read the table type node.
    return loadType(ImpDesc.getExternalTableType());
  }
  case ExternalType::Memory: {
    // Read the memory type node.
    return loadType(ImpDesc.getExternalMemoryType());
  }
  case ExternalType::Global: {
    // Read the global type node.
    EXPECTED_TRY(loadType(ImpDesc.getExternalGlobalType()));
    // Import the mutable globals are for ImportExportMutGlobals proposal.
    if (ImpDesc.getExternalGlobalType().getValMut() == ValMut::Var &&
        unlikely(!Conf.hasProposal(Proposal::ImportExportMutGlobals))) {
      return logNeedProposal(ErrCode::Value::InvalidMut,
                             Proposal::ImportExportMutGlobals,
                             FMgr.getLastOffset(), ASTNodeAttr::Desc_Import);
    }
    return {};
  }
  case ExternalType::Tag: {
    if (!Conf.hasProposal(Proposal::ExceptionHandling)) {
      return logNeedProposal(ErrCode::Value::MalformedImportKind,
                             Proposal::ExceptionHandling, FMgr.getLastOffset(),
                             ASTNodeAttr::Module);
    }
    // Read the Tag type node.
    return loadType(ImpDesc.getExternalTagType());
  }
  default:
    return logLoadError(ErrCode::Value::MalformedImportKind,
                        FMgr.getLastOffset(), ASTNodeAttr::Desc_Import);
  }
}

// Load binary of Export description. See "include/loader/loader.h".
Expect<void> Loader::loadDesc(AST::ExportDesc &ExpDesc) {
  auto ReportError = [this](auto E) {
    return logLoadError(E, FMgr.getLastOffset(), ASTNodeAttr::Desc_Export);
  };

  // Read external name to export.
  EXPECTED_TRY(FMgr.readName().map_error(ReportError).map([&](std::string S) {
    ExpDesc.setExternalName(S);
  }));

  // Read external type.
  EXPECTED_TRY(FMgr.readByte().map_error(ReportError).map([&](uint8_t B) {
    ExpDesc.setExternalType(static_cast<ExternalType>(B));
  }));
  switch (ExpDesc.getExternalType()) {
  case ExternalType::Function:
  case ExternalType::Table:
  case ExternalType::Memory:
  case ExternalType::Global:
    break;
  case ExternalType::Tag:
    if (!Conf.hasProposal(Proposal::ExceptionHandling)) {
      return logNeedProposal(ErrCode::Value::MalformedImportKind,
                             Proposal::ExceptionHandling, FMgr.getLastOffset(),
                             ASTNodeAttr::Module);
    }
    break;
  default:
    return logLoadError(ErrCode::Value::MalformedExportKind,
                        FMgr.getLastOffset(), ASTNodeAttr::Desc_Export);
  }

  // Read external index to export.
  EXPECTED_TRY(FMgr.readU32().map_error(ReportError).map([&](uint32_t Idx) {
    ExpDesc.setExternalIndex(Idx);
  }));
  return {};
}

} // namespace Loader
} // namespace WasmEdge

Line	Count	Source
1		// SPDX-License-Identifier: Apache-2.0
2		// SPDX-FileCopyrightText: 2019-2024 Second State INC
3
4		#include "loader/loader.h"
5
6		namespace WasmEdge {
7		namespace Loader {
8
9		// Load binary of Import description. See "include/loader/loader.h".
10	11.7k	Expect<void> Loader::loadDesc(AST::ImportDesc &ImpDesc) {
11	11.7k	auto ReportError = [this](auto E) {
12	81	return logLoadError(E, FMgr.getLastOffset(), ASTNodeAttr::Desc_Import);
13	81	};
14
15		// Read the module name.
16	11.7k	EXPECTED_TRY(FMgr.readName().map_error(ReportError).map([&](std::string S) {
17	11.7k	ImpDesc.setModuleName(S);
18	11.7k	}));
19
20		// Read the external name.
21	11.7k	EXPECTED_TRY(FMgr.readName().map_error(ReportError).map([&](std::string S) {
22	11.7k	ImpDesc.setExternalName(S);
23	11.7k	}));
24
25		// Read the external type.
26	11.7k	EXPECTED_TRY(FMgr.readByte().map_error(ReportError).map([&](uint8_t B) {
27	11.7k	ImpDesc.setExternalType(static_cast<ExternalType>(B));
28	11.7k	}));
29
30		// Make content node according to external type.
31	11.7k	switch (ImpDesc.getExternalType()) {
32	2.34k	case ExternalType::Function: {
33		// Read the function type index.
34	2.34k	EXPECTED_TRY(FMgr.readU32().map_error(ReportError).map([&](uint32_t Idx) {
35	2.33k	ImpDesc.setExternalFuncTypeIdx(Idx);
36	2.33k	}));
37	2.33k	return {};
38	2.34k	}
39	1.12k	case ExternalType::Table: {
40		// Read the table type node.
41	1.12k	return loadType(ImpDesc.getExternalTableType());
42	2.34k	}
43	347	case ExternalType::Memory: {
44		// Read the memory type node.
45	347	return loadType(ImpDesc.getExternalMemoryType());
46	2.34k	}
47	7.86k	case ExternalType::Global: {
48		// Read the global type node.
49	7.86k	EXPECTED_TRY(loadType(ImpDesc.getExternalGlobalType()));
50		// Import the mutable globals are for ImportExportMutGlobals proposal.
51	7.85k	if (ImpDesc.getExternalGlobalType().getValMut() == ValMut::Var &&
52	572	unlikely(!Conf.hasProposal(Proposal::ImportExportMutGlobals))) {
53	0	return logNeedProposal(ErrCode::Value::InvalidMut,
54	0	Proposal::ImportExportMutGlobals,
55	0	FMgr.getLastOffset(), ASTNodeAttr::Desc_Import);
56	0	}
57	7.85k	return {};
58	7.85k	}
59	23	case ExternalType::Tag: {
60	23	if (!Conf.hasProposal(Proposal::ExceptionHandling)) {
61	0	return logNeedProposal(ErrCode::Value::MalformedImportKind,
62	0	Proposal::ExceptionHandling, FMgr.getLastOffset(),
63	0	ASTNodeAttr::Module);
64	0	}
65		// Read the Tag type node.
66	23	return loadType(ImpDesc.getExternalTagType());
67	23	}
68	8	default:
69	8	return logLoadError(ErrCode::Value::MalformedImportKind,
70	8	FMgr.getLastOffset(), ASTNodeAttr::Desc_Import);
71	11.7k	}
72	11.7k	}
73
74		// Load binary of Export description. See "include/loader/loader.h".
75	18.2k	Expect<void> Loader::loadDesc(AST::ExportDesc &ExpDesc) {
76	18.2k	auto ReportError = [this](auto E) {
77	49	return logLoadError(E, FMgr.getLastOffset(), ASTNodeAttr::Desc_Export);
78	49	};
79
80		// Read external name to export.
81	18.2k	EXPECTED_TRY(FMgr.readName().map_error(ReportError).map([&](std::string S) {
82	18.1k	ExpDesc.setExternalName(S);
83	18.1k	}));
84
85		// Read external type.
86	18.1k	EXPECTED_TRY(FMgr.readByte().map_error(ReportError).map([&](uint8_t B) {
87	18.1k	ExpDesc.setExternalType(static_cast<ExternalType>(B));
88	18.1k	}));
89	18.1k	switch (ExpDesc.getExternalType()) {
90	14.8k	case ExternalType::Function:
91	15.2k	case ExternalType::Table:
92	15.8k	case ExternalType::Memory:
93	16.1k	case ExternalType::Global:
94	16.1k	break;
95	1.95k	case ExternalType::Tag:
96	1.95k	if (!Conf.hasProposal(Proposal::ExceptionHandling)) {
97	0	return logNeedProposal(ErrCode::Value::MalformedImportKind,
98	0	Proposal::ExceptionHandling, FMgr.getLastOffset(),
99	0	ASTNodeAttr::Module);
100	0	}
101	1.95k	break;
102	1.95k	default:
103	12	return logLoadError(ErrCode::Value::MalformedExportKind,
104	12	FMgr.getLastOffset(), ASTNodeAttr::Desc_Export);
105	18.1k	}
106
107		// Read external index to export.
108	18.1k	EXPECTED_TRY(FMgr.readU32().map_error(ReportError).map([&](uint32_t Idx) {
109	18.1k	ExpDesc.setExternalIndex(Idx);
110	18.1k	}));
111	18.1k	return {};
112	18.1k	}
113
114		} // namespace Loader
115		} // namespace WasmEdge

Coverage Report

Created: 2025-11-24 06:51