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

Source
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright The WasmEdge Authors

#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));
  }));

  // Create the content node according to the 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()));
    // Mutable global imports are for the 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: Copyright The WasmEdge Authors
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	18.3k	Expect<void> Loader::loadDesc(AST::ImportDesc &ImpDesc) {
11	18.3k	auto ReportError = [this](auto E) {
12	169	return logLoadError(E, FMgr.getLastOffset(), ASTNodeAttr::Desc_Import);
13	169	};
14
15		// Read the module name.
16	18.3k	EXPECTED_TRY(FMgr.readName().map_error(ReportError).map([&](std::string S) {
17	18.3k	ImpDesc.setModuleName(S);
18	18.3k	}));
19
20		// Read the external name.
21	18.3k	EXPECTED_TRY(FMgr.readName().map_error(ReportError).map([&](std::string S) {
22	18.2k	ImpDesc.setExternalName(S);
23	18.2k	}));
24
25		// Read the external type.
26	18.2k	EXPECTED_TRY(FMgr.readByte().map_error(ReportError).map([&](uint8_t B) {
27	18.2k	ImpDesc.setExternalType(static_cast<ExternalType>(B));
28	18.2k	}));
29
30		// Create the content node according to the external type.
31	18.2k	switch (ImpDesc.getExternalType()) {
32	4.11k	case ExternalType::Function: {
33		// Read the function type index.
34	4.11k	EXPECTED_TRY(FMgr.readU32().map_error(ReportError).map([&](uint32_t Idx) {
35	4.10k	ImpDesc.setExternalFuncTypeIdx(Idx);
36	4.10k	}));
37	4.10k	return {};
38	4.11k	}
39	1.09k	case ExternalType::Table: {
40		// Read the table type node.
41	1.09k	return loadType(ImpDesc.getExternalTableType());
42	4.11k	}
43	1.39k	case ExternalType::Memory: {
44		// Read the memory type node.
45	1.39k	return loadType(ImpDesc.getExternalMemoryType());
46	4.11k	}
47	10.9k	case ExternalType::Global: {
48		// Read the global type node.
49	10.9k	EXPECTED_TRY(loadType(ImpDesc.getExternalGlobalType()));
50		// Mutable global imports are for the ImportExportMutGlobals proposal.
51	10.9k	if (ImpDesc.getExternalGlobalType().getValMut() == ValMut::Var &&
52	865	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	10.9k	return {};
58	10.9k	}
59	643	case ExternalType::Tag: {
60	643	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	643	return loadType(ImpDesc.getExternalTagType());
67	643	}
68	15	default:
69	15	return logLoadError(ErrCode::Value::MalformedImportKind,
70	15	FMgr.getLastOffset(), ASTNodeAttr::Desc_Import);
71	18.2k	}
72	18.2k	}
73
74		// Load binary of Export description. See "include/loader/loader.h".
75	19.8k	Expect<void> Loader::loadDesc(AST::ExportDesc &ExpDesc) {
76	19.8k	auto ReportError = [this](auto E) {
77	120	return logLoadError(E, FMgr.getLastOffset(), ASTNodeAttr::Desc_Export);
78	120	};
79
80		// Read external name to export.
81	19.8k	EXPECTED_TRY(FMgr.readName().map_error(ReportError).map([&](std::string S) {
82	19.7k	ExpDesc.setExternalName(S);
83	19.7k	}));
84
85		// Read external type.
86	19.7k	EXPECTED_TRY(FMgr.readByte().map_error(ReportError).map([&](uint8_t B) {
87	19.7k	ExpDesc.setExternalType(static_cast<ExternalType>(B));
88	19.7k	}));
89	19.7k	switch (ExpDesc.getExternalType()) {
90	15.8k	case ExternalType::Function:
91	17.0k	case ExternalType::Table:
92	18.3k	case ExternalType::Memory:
93	18.9k	case ExternalType::Global:
94	18.9k	break;
95	737	case ExternalType::Tag:
96	737	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	737	break;
102	737	default:
103	27	return logLoadError(ErrCode::Value::MalformedExportKind,
104	27	FMgr.getLastOffset(), ASTNodeAttr::Desc_Export);
105	19.7k	}
106
107		// Read external index to export.
108	19.7k	EXPECTED_TRY(FMgr.readU32().map_error(ReportError).map([&](uint32_t Idx) {
109	19.7k	ExpDesc.setExternalIndex(Idx);
110	19.7k	}));
111	19.7k	return {};
112	19.7k	}
113
114		} // namespace Loader
115		} // namespace WasmEdge

Coverage Report

Created: 2026-08-13 06:09