summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/parser/contexts.h62
-rw-r--r--src/parser/input-impl.h6
-rw-r--r--src/parser/input.h2
-rw-r--r--src/parser/lexer.cpp5
-rw-r--r--src/parser/parsers.h68
5 files changed, 142 insertions, 1 deletions
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
index 507a54342..c14a555c5 100644
--- a/src/parser/contexts.h
+++ b/src/parser/contexts.h
@@ -406,6 +406,20 @@ struct NullInstrParserCtx {
Result<> makeI64Const(Index, uint64_t) { return Ok{}; }
Result<> makeF32Const(Index, float) { return Ok{}; }
Result<> makeF64Const(Index, double) { return Ok{}; }
+ Result<> makeI8x16Const(Index, const std::array<uint8_t, 16>&) {
+ return Ok{};
+ }
+ Result<> makeI16x8Const(Index, const std::array<uint16_t, 8>&) {
+ return Ok{};
+ }
+ Result<> makeI32x4Const(Index, const std::array<uint32_t, 4>&) {
+ return Ok{};
+ }
+ Result<> makeI64x2Const(Index, const std::array<uint64_t, 2>&) {
+ return Ok{};
+ }
+ Result<> makeF32x4Const(Index, const std::array<float, 4>&) { return Ok{}; }
+ Result<> makeF64x2Const(Index, const std::array<double, 2>&) { return Ok{}; }
Result<> makeLoad(Index, Type, bool, int, bool, MemoryIdxT*, MemargT) {
return Ok{};
}
@@ -1542,6 +1556,54 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
return withLoc(pos, irBuilder.makeConst(Literal(c)));
}
+ Result<> makeI8x16Const(Index pos, const std::array<uint8_t, 16>& vals) {
+ std::array<Literal, 16> lanes;
+ for (size_t i = 0; i < 16; ++i) {
+ lanes[i] = Literal(uint32_t(vals[i]));
+ }
+ return withLoc(pos, irBuilder.makeConst(Literal(lanes)));
+ }
+
+ Result<> makeI16x8Const(Index pos, const std::array<uint16_t, 8>& vals) {
+ std::array<Literal, 8> lanes;
+ for (size_t i = 0; i < 8; ++i) {
+ lanes[i] = Literal(uint32_t(vals[i]));
+ }
+ return withLoc(pos, irBuilder.makeConst(Literal(lanes)));
+ }
+
+ Result<> makeI32x4Const(Index pos, const std::array<uint32_t, 4>& vals) {
+ std::array<Literal, 4> lanes;
+ for (size_t i = 0; i < 4; ++i) {
+ lanes[i] = Literal(vals[i]);
+ }
+ return withLoc(pos, irBuilder.makeConst(Literal(lanes)));
+ }
+
+ Result<> makeI64x2Const(Index pos, const std::array<uint64_t, 2>& vals) {
+ std::array<Literal, 2> lanes;
+ for (size_t i = 0; i < 2; ++i) {
+ lanes[i] = Literal(vals[i]);
+ }
+ return withLoc(pos, irBuilder.makeConst(Literal(lanes)));
+ }
+
+ Result<> makeF32x4Const(Index pos, const std::array<float, 4>& vals) {
+ std::array<Literal, 4> lanes;
+ for (size_t i = 0; i < 4; ++i) {
+ lanes[i] = Literal(vals[i]);
+ }
+ return withLoc(pos, irBuilder.makeConst(Literal(lanes)));
+ }
+
+ Result<> makeF64x2Const(Index pos, const std::array<double, 2>& vals) {
+ std::array<Literal, 2> lanes;
+ for (size_t i = 0; i < 2; ++i) {
+ lanes[i] = Literal(vals[i]);
+ }
+ return withLoc(pos, irBuilder.makeConst(Literal(lanes)));
+ }
+
Result<> makeLoad(Index pos,
Type type,
bool signed_,
diff --git a/src/parser/input-impl.h b/src/parser/input-impl.h
index 3ffce07f8..e3cf52015 100644
--- a/src/parser/input-impl.h
+++ b/src/parser/input-impl.h
@@ -170,8 +170,14 @@ inline std::optional<uint32_t> ParseInput::takeI32() {
return takeI<uint32_t>();
}
+inline std::optional<uint16_t> ParseInput::takeI16() {
+ return takeI<uint16_t>();
+}
+
inline std::optional<uint8_t> ParseInput::takeU8() { return takeU<uint8_t>(); }
+inline std::optional<uint8_t> ParseInput::takeI8() { return takeI<uint8_t>(); }
+
inline std::optional<double> ParseInput::takeF64() {
if (auto t = peek()) {
if (auto d = t->getF64()) {
diff --git a/src/parser/input.h b/src/parser/input.h
index d4fdde1bd..6086ed1a5 100644
--- a/src/parser/input.h
+++ b/src/parser/input.h
@@ -54,7 +54,9 @@ struct ParseInput {
std::optional<uint64_t> takeI64();
std::optional<uint32_t> takeU32();
std::optional<uint32_t> takeI32();
+ std::optional<uint16_t> takeI16();
std::optional<uint8_t> takeU8();
+ std::optional<uint8_t> takeI8();
std::optional<double> takeF64();
std::optional<float> takeF32();
std::optional<std::string> takeString();
diff --git a/src/parser/lexer.cpp b/src/parser/lexer.cpp
index 288660c76..2625bf8fd 100644
--- a/src/parser/lexer.cpp
+++ b/src/parser/lexer.cpp
@@ -811,7 +811,12 @@ template std::optional<uint64_t> Token::getI<uint64_t>() const;
template std::optional<uint32_t> Token::getU<uint32_t>() const;
template std::optional<int32_t> Token::getS<int32_t>() const;
template std::optional<uint32_t> Token::getI<uint32_t>() const;
+template std::optional<uint16_t> Token::getU<uint16_t>() const;
+template std::optional<int16_t> Token::getS<int16_t>() const;
+template std::optional<uint16_t> Token::getI<uint16_t>() const;
template std::optional<uint8_t> Token::getU<uint8_t>() const;
+template std::optional<int8_t> Token::getS<int8_t>() const;
+template std::optional<uint8_t> Token::getI<uint8_t>() const;
std::optional<double> Token::getF64() const {
constexpr int signif = 52;
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index d62645441..db4c716f1 100644
--- a/src/parser/parsers.h
+++ b/src/parser/parsers.h
@@ -1362,7 +1362,73 @@ template<typename Ctx> Result<> makeConst(Ctx& ctx, Index pos, Type type) {
}
return ctx.in.err("expected f64");
case Type::v128:
- return ctx.in.err("unimplemented instruction");
+ if (ctx.in.takeKeyword("i8x16"sv)) {
+ std::array<uint8_t, 16> vals;
+ for (size_t i = 0; i < 16; ++i) {
+ auto val = ctx.in.takeI8();
+ if (!val) {
+ return ctx.in.err("expected i8 value");
+ }
+ vals[i] = *val;
+ }
+ return ctx.makeI8x16Const(pos, vals);
+ }
+ if (ctx.in.takeKeyword("i16x8"sv)) {
+ std::array<uint16_t, 8> vals;
+ for (size_t i = 0; i < 8; ++i) {
+ auto val = ctx.in.takeI16();
+ if (!val) {
+ return ctx.in.err("expected i16 value");
+ }
+ vals[i] = *val;
+ }
+ return ctx.makeI16x8Const(pos, vals);
+ }
+ if (ctx.in.takeKeyword("i32x4"sv)) {
+ std::array<uint32_t, 4> vals;
+ for (size_t i = 0; i < 4; ++i) {
+ auto val = ctx.in.takeI32();
+ if (!val) {
+ return ctx.in.err("expected i32 value");
+ }
+ vals[i] = *val;
+ }
+ return ctx.makeI32x4Const(pos, vals);
+ }
+ if (ctx.in.takeKeyword("i64x2"sv)) {
+ std::array<uint64_t, 2> vals;
+ for (size_t i = 0; i < 2; ++i) {
+ auto val = ctx.in.takeI64();
+ if (!val) {
+ return ctx.in.err("expected i64 value");
+ }
+ vals[i] = *val;
+ }
+ return ctx.makeI64x2Const(pos, vals);
+ }
+ if (ctx.in.takeKeyword("f32x4"sv)) {
+ std::array<float, 4> vals;
+ for (size_t i = 0; i < 4; ++i) {
+ auto val = ctx.in.takeF32();
+ if (!val) {
+ return ctx.in.err("expected f32 value");
+ }
+ vals[i] = *val;
+ }
+ return ctx.makeF32x4Const(pos, vals);
+ }
+ if (ctx.in.takeKeyword("f64x2"sv)) {
+ std::array<double, 2> vals;
+ for (size_t i = 0; i < 2; ++i) {
+ auto val = ctx.in.takeF64();
+ if (!val) {
+ return ctx.in.err("expected f64 value");
+ }
+ vals[i] = *val;
+ }
+ return ctx.makeF64x2Const(pos, vals);
+ }
+ return ctx.in.err("expected SIMD vector shape");
case Type::none:
case Type::unreachable:
break;
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-03 18:41:40 +0000