summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/gen-s-parser.inc9
-rw-r--r--src/ir/ReFinalize.cpp1
-rw-r--r--src/ir/cost.h3
-rw-r--r--src/ir/effects.h5
-rw-r--r--src/ir/possible-contents.cpp1
-rw-r--r--src/parser/parsers.h5
-rw-r--r--src/passes/Directize.cpp3
-rw-r--r--src/passes/Print.cpp6
-rw-r--r--src/passes/Unsubtyping.cpp4
-rw-r--r--src/wasm-binary.h2
-rw-r--r--src/wasm-builder.h14
-rw-r--r--src/wasm-delegations-fields.def10
-rw-r--r--src/wasm-delegations.def1
-rw-r--r--src/wasm-interpreter.h56
-rw-r--r--src/wasm-ir-builder.h1
-rw-r--r--src/wasm-s-parser.h1
-rw-r--r--src/wasm.h15
-rw-r--r--src/wasm/wasm-binary.cpp25
-rw-r--r--src/wasm/wasm-s-parser.cpp18
-rw-r--r--src/wasm/wasm-stack.cpp6
-rw-r--r--src/wasm/wasm-validator.cpp22
-rw-r--r--src/wasm/wasm.cpp8
-rw-r--r--src/wasm2js.h4
23 files changed, 220 insertions, 0 deletions
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index e09bacfc2..a7cdc76c7 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -3357,6 +3357,9 @@ switch (buf[0]) {
switch (buf[1]) {
case 'a': {
switch (buf[6]) {
+ case 'c':
+ if (op == "table.copy"sv) { return makeTableCopy(s); }
+ goto parse_error;
case 'f':
if (op == "table.fill"sv) { return makeTableFill(s); }
goto parse_error;
@@ -8619,6 +8622,12 @@ switch (buf[0]) {
switch (buf[1]) {
case 'a': {
switch (buf[6]) {
+ case 'c':
+ if (op == "table.copy"sv) {
+ CHECK_ERR(makeTableCopy(ctx, pos));
+ return Ok{};
+ }
+ goto parse_error;
case 'f':
if (op == "table.fill"sv) {
CHECK_ERR(makeTableFill(ctx, pos));
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
index bfdcfe7a6..3d74b1422 100644
--- a/src/ir/ReFinalize.cpp
+++ b/src/ir/ReFinalize.cpp
@@ -125,6 +125,7 @@ void ReFinalize::visitTableSet(TableSet* curr) { curr->finalize(); }
void ReFinalize::visitTableSize(TableSize* curr) { curr->finalize(); }
void ReFinalize::visitTableGrow(TableGrow* curr) { curr->finalize(); }
void ReFinalize::visitTableFill(TableFill* curr) { curr->finalize(); }
+void ReFinalize::visitTableCopy(TableCopy* curr) { curr->finalize(); }
void ReFinalize::visitTry(Try* curr) { curr->finalize(); }
void ReFinalize::visitThrow(Throw* curr) { curr->finalize(); }
void ReFinalize::visitRethrow(Rethrow* curr) { curr->finalize(); }
diff --git a/src/ir/cost.h b/src/ir/cost.h
index efc50eb1b..d3a483535 100644
--- a/src/ir/cost.h
+++ b/src/ir/cost.h
@@ -577,6 +577,9 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
CostType visitTableFill(TableFill* curr) {
return 6 + visit(curr->dest) + visit(curr->value) + visit(curr->size);
}
+ CostType visitTableCopy(TableCopy* curr) {
+ return 6 + visit(curr->dest) + visit(curr->source) + visit(curr->size);
+ }
CostType visitTry(Try* curr) {
// We assume no exception will be thrown in most cases
return visit(curr->body);
diff --git a/src/ir/effects.h b/src/ir/effects.h
index 9bdf08c74..0e45ec70c 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -696,6 +696,11 @@ private:
parent.writesTable = true;
parent.implicitTrap = true;
}
+ void visitTableCopy(TableCopy* curr) {
+ parent.readsTable = true;
+ parent.writesTable = true;
+ parent.implicitTrap = true;
+ }
void visitTry(Try* curr) {
if (curr->delegateTarget.is()) {
parent.delegateTargets.insert(curr->delegateTarget);
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
index 06d380a95..7c9a4fc6b 100644
--- a/src/ir/possible-contents.cpp
+++ b/src/ir/possible-contents.cpp
@@ -662,6 +662,7 @@ struct InfoCollector
void visitTableSize(TableSize* curr) { addRoot(curr); }
void visitTableGrow(TableGrow* curr) { addRoot(curr); }
void visitTableFill(TableFill* curr) { addRoot(curr); }
+ void visitTableCopy(TableCopy* curr) { addRoot(curr); }
void visitNop(Nop* curr) {}
void visitUnreachable(Unreachable* curr) {}
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index 65fd98a24..3a4f9c212 100644
--- a/src/parser/parsers.h
+++ b/src/parser/parsers.h
@@ -118,6 +118,7 @@ template<typename Ctx> Result<> makeTableSet(Ctx&, Index);
template<typename Ctx> Result<> makeTableSize(Ctx&, Index);
template<typename Ctx> Result<> makeTableGrow(Ctx&, Index);
template<typename Ctx> Result<> makeTableFill(Ctx&, Index);
+template<typename Ctx> Result<> makeTableCopy(Ctx&, Index);
template<typename Ctx> Result<> makeTry(Ctx&, Index);
template<typename Ctx>
Result<> makeTryOrCatchBody(Ctx&, Index, Type type, bool isTry);
@@ -1264,6 +1265,10 @@ template<typename Ctx> Result<> makeTableFill(Ctx& ctx, Index pos) {
return ctx.in.err("unimplemented instruction");
}
+template<typename Ctx> Result<> makeTableCopy(Ctx& ctx, Index pos) {
+ return ctx.in.err("unimplemented instruction");
+}
+
template<typename Ctx> Result<> makeTry(Ctx& ctx, Index pos) {
return ctx.in.err("unimplemented instruction");
}
diff --git a/src/passes/Directize.cpp b/src/passes/Directize.cpp
index 34930d127..78294d59d 100644
--- a/src/passes/Directize.cpp
+++ b/src/passes/Directize.cpp
@@ -263,6 +263,9 @@ struct Directize : public Pass {
void visitTableFill(TableFill* curr) {
tablesWithSet.insert(curr->table);
}
+ void visitTableCopy(TableCopy* curr) {
+ tablesWithSet.insert(curr->destTable);
+ }
};
Finder(tablesWithSet).walkFunction(func);
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index 51d261126..889eb87fd 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -1950,6 +1950,12 @@ struct PrintExpressionContents
printMedium(o, "table.fill ");
printName(curr->table, o);
}
+ void visitTableCopy(TableCopy* curr) {
+ printMedium(o, "table.copy ");
+ printName(curr->destTable, o);
+ o << ' ';
+ printName(curr->sourceTable, o);
+ }
void visitTry(Try* curr) {
printMedium(o, "try");
if (curr->name.is()) {
diff --git a/src/passes/Unsubtyping.cpp b/src/passes/Unsubtyping.cpp
index 87da111f0..e5d9453a8 100644
--- a/src/passes/Unsubtyping.cpp
+++ b/src/passes/Unsubtyping.cpp
@@ -446,6 +446,10 @@ struct Unsubtyping
void visitTableFill(TableFill* curr) {
noteSubtype(curr->value->type, getModule()->getTable(curr->table)->type);
}
+ void visitTableCopy(TableCopy* curr) {
+ noteSubtype(getModule()->getTable(curr->sourceTable)->type,
+ getModule()->getTable(curr->destTable)->type);
+ }
void visitTry(Try* curr) {
noteSubtype(curr->body->type, curr->type);
for (auto* body : curr->catchBodies) {
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 9e72b3b82..752f306fe 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -1132,6 +1132,7 @@ enum ASTNodes {
TableGrow = 0x0f,
TableSize = 0x10,
TableFill = 0x11,
+ TableCopy = 0x0e,
RefNull = 0xd0,
RefIsNull = 0xd1,
RefFunc = 0xd2,
@@ -1844,6 +1845,7 @@ public:
bool maybeVisitTableSize(Expression*& out, uint32_t code);
bool maybeVisitTableGrow(Expression*& out, uint32_t code);
bool maybeVisitTableFill(Expression*& out, uint32_t code);
+ bool maybeVisitTableCopy(Expression*& out, uint32_t code);
bool maybeVisitRefI31(Expression*& out, uint32_t code);
bool maybeVisitI31Get(Expression*& out, uint32_t code);
bool maybeVisitRefTest(Expression*& out, uint32_t code);
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index 9a59b4015..9e2881145 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -771,6 +771,20 @@ public:
ret->finalize();
return ret;
}
+ TableCopy* makeTableCopy(Expression* dest,
+ Expression* source,
+ Expression* size,
+ Name destTable,
+ Name sourceTable) {
+ auto* ret = wasm.allocator.alloc<TableCopy>();
+ ret->dest = dest;
+ ret->source = source;
+ ret->size = size;
+ ret->destTable = destTable;
+ ret->sourceTable = sourceTable;
+ ret->finalize();
+ return ret;
+ }
private:
Try* makeTry(Name name,
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
index 3ab112bdd..d7567b38d 100644
--- a/src/wasm-delegations-fields.def
+++ b/src/wasm-delegations-fields.def
@@ -576,6 +576,16 @@ switch (DELEGATE_ID) {
DELEGATE_END(TableFill);
break;
}
+ case Expression::Id::TableCopyId: {
+ DELEGATE_START(TableCopy);
+ DELEGATE_FIELD_CHILD(TableCopy, size);
+ DELEGATE_FIELD_CHILD(TableCopy, source);
+ DELEGATE_FIELD_CHILD(TableCopy, dest);
+ DELEGATE_FIELD_NAME_KIND(TableCopy, sourceTable, ModuleItemKind::Table);
+ DELEGATE_FIELD_NAME_KIND(TableCopy, destTable, ModuleItemKind::Table);
+ DELEGATE_END(TableCopy);
+ break;
+ }
case Expression::Id::TryId: {
DELEGATE_START(Try);
DELEGATE_FIELD_SCOPE_NAME_USE(Try, delegateTarget);
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
index a9c9c3f75..903b19bf7 100644
--- a/src/wasm-delegations.def
+++ b/src/wasm-delegations.def
@@ -63,6 +63,7 @@ DELEGATE(TableSet);
DELEGATE(TableSize);
DELEGATE(TableGrow);
DELEGATE(TableFill);
+DELEGATE(TableCopy);
DELEGATE(Try);
DELEGATE(Throw);
DELEGATE(Rethrow);
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index 8eb52e634..3599def90 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -1392,6 +1392,7 @@ public:
Flow visitTableSize(TableSize* curr) { WASM_UNREACHABLE("unimp"); }
Flow visitTableGrow(TableGrow* curr) { WASM_UNREACHABLE("unimp"); }
Flow visitTableFill(TableFill* curr) { WASM_UNREACHABLE("unimp"); }
+ Flow visitTableCopy(TableCopy* curr) { WASM_UNREACHABLE("unimp"); }
Flow visitTry(Try* curr) { WASM_UNREACHABLE("unimp"); }
Flow visitThrow(Throw* curr) {
NOTE_ENTER("Throw");
@@ -2210,6 +2211,10 @@ public:
NOTE_ENTER("TableFill");
return Flow(NONCONSTANT_FLOW);
}
+ Flow visitTableCopy(TableCopy* curr) {
+ NOTE_ENTER("TableCopy");
+ return Flow(NONCONSTANT_FLOW);
+ }
Flow visitLoad(Load* curr) {
NOTE_ENTER("Load");
return Flow(NONCONSTANT_FLOW);
@@ -3027,6 +3032,57 @@ public:
return Flow();
}
+ Flow visitTableCopy(TableCopy* curr) {
+ NOTE_ENTER("TableCopy");
+ Flow dest = self()->visit(curr->dest);
+ if (dest.breaking()) {
+ return dest;
+ }
+ Flow source = self()->visit(curr->source);
+ if (source.breaking()) {
+ return source;
+ }
+ Flow size = self()->visit(curr->size);
+ if (size.breaking()) {
+ return size;
+ }
+ NOTE_EVAL1(dest);
+ NOTE_EVAL1(source);
+ NOTE_EVAL1(size);
+ Address destVal(dest.getSingleValue().getUnsigned());
+ Address sourceVal(source.getSingleValue().getUnsigned());
+ Address sizeVal(size.getSingleValue().getUnsigned());
+
+ auto destInfo = getTableInterfaceInfo(curr->destTable);
+ auto sourceInfo = getTableInterfaceInfo(curr->sourceTable);
+ auto destTableSize = destInfo.interface->tableSize(destInfo.name);
+ auto sourceTableSize = sourceInfo.interface->tableSize(sourceInfo.name);
+ if (sourceVal + sizeVal > sourceTableSize ||
+ destVal + sizeVal > destTableSize ||
+ // FIXME: better/cheaper way to detect wrapping?
+ sourceVal + sizeVal < sourceVal || sourceVal + sizeVal < sizeVal ||
+ destVal + sizeVal < destVal || destVal + sizeVal < sizeVal) {
+ trap("out of bounds segment access in table.copy");
+ }
+
+ int64_t start = 0;
+ int64_t end = sizeVal;
+ int step = 1;
+ // Reverse direction if source is below dest
+ if (sourceVal < destVal) {
+ start = int64_t(sizeVal) - 1;
+ end = -1;
+ step = -1;
+ }
+ for (int64_t i = start; i != end; i += step) {
+ destInfo.interface->tableStore(
+ destInfo.name,
+ destVal + i,
+ sourceInfo.interface->tableLoad(sourceInfo.name, sourceVal + i));
+ }
+ return {};
+ }
+
Flow visitLocalGet(LocalGet* curr) {
NOTE_ENTER("LocalGet");
auto index = curr->index;
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
index b42d40892..c0fce32c7 100644
--- a/src/wasm-ir-builder.h
+++ b/src/wasm-ir-builder.h
@@ -135,6 +135,7 @@ public:
// [[nodiscard]] Result<> makeTableSize();
// [[nodiscard]] Result<> makeTableGrow();
// [[nodiscard]] Result<> makeTableFill();
+ // [[nodiscard]] Result<> makeTableCopy();
// [[nodiscard]] Result<> makeTry();
// [[nodiscard]] Result<> makeThrow();
// [[nodiscard]] Result<> makeRethrow();
diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h
index 6853f2c01..bbd07e3be 100644
--- a/src/wasm-s-parser.h
+++ b/src/wasm-s-parser.h
@@ -282,6 +282,7 @@ private:
Expression* makeTableSize(Element& s);
Expression* makeTableGrow(Element& s);
Expression* makeTableFill(Element& s);
+ Expression* makeTableCopy(Element& s);
Expression* makeTry(Element& s);
Expression* makeTryOrCatchBody(Element& s, Type type, bool isTry);
Expression* makeThrow(Element& s);
diff --git a/src/wasm.h b/src/wasm.h
index 1792b1538..ba797d773 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -699,6 +699,7 @@ public:
TableSizeId,
TableGrowId,
TableFillId,
+ TableCopyId,
TryId,
ThrowId,
RethrowId,
@@ -1435,6 +1436,20 @@ public:
void finalize();
};
+class TableCopy : public SpecificExpression<Expression::TableCopyId> {
+public:
+ TableCopy() = default;
+ TableCopy(MixedArena& allocator) : TableCopy() {}
+
+ Expression* dest;
+ Expression* source;
+ Expression* size;
+ Name destTable;
+ Name sourceTable;
+
+ void finalize();
+};
+
class Try : public SpecificExpression<Expression::TryId> {
public:
Try(MixedArena& allocator) : catchTags(allocator), catchBodies(allocator) {}
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index 6b74f2597..3c01e5df5 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -4062,6 +4062,9 @@ BinaryConsts::ASTNodes WasmBinaryReader::readExpression(Expression*& curr) {
if (maybeVisitTableFill(curr, opcode)) {
break;
}
+ if (maybeVisitTableCopy(curr, opcode)) {
+ break;
+ }
throwError("invalid code after misc prefix: " + std::to_string(opcode));
break;
}
@@ -5436,6 +5439,28 @@ bool WasmBinaryReader::maybeVisitTableFill(Expression*& out, uint32_t code) {
return true;
}
+bool WasmBinaryReader::maybeVisitTableCopy(Expression*& out, uint32_t code) {
+ if (code != BinaryConsts::TableCopy) {
+ return false;
+ }
+ Index destTableIdx = getU32LEB();
+ if (destTableIdx >= wasm.tables.size()) {
+ throwError("bad table index");
+ }
+ Index sourceTableIdx = getU32LEB();
+ if (sourceTableIdx >= wasm.tables.size()) {
+ throwError("bad table index");
+ }
+ auto* size = popNonVoidExpression();
+ auto* source = popNonVoidExpression();
+ auto* dest = popNonVoidExpression();
+ auto* ret = Builder(wasm).makeTableCopy(dest, source, size, Name(), Name());
+ tableRefs[destTableIdx].push_back(&ret->destTable);
+ tableRefs[sourceTableIdx].push_back(&ret->sourceTable);
+ out = ret;
+ return true;
+}
+
bool WasmBinaryReader::maybeVisitBinary(Expression*& out, uint8_t code) {
Binary* curr;
#define INT_TYPED_CODE(code) \
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
index 6f3fbe76b..7b415813e 100644
--- a/src/wasm/wasm-s-parser.cpp
+++ b/src/wasm/wasm-s-parser.cpp
@@ -2706,6 +2706,24 @@ Expression* SExpressionWasmBuilder::makeTableFill(Element& s) {
return Builder(wasm).makeTableFill(tableName, dest, value, size);
}
+Expression* SExpressionWasmBuilder::makeTableCopy(Element& s) {
+ auto destTableName = s[1]->str();
+ auto* destTable = wasm.getTableOrNull(destTableName);
+ if (!destTable) {
+ throw SParseException("invalid dest table name in table.copy", s);
+ }
+ auto sourceTableName = s[2]->str();
+ auto* sourceTable = wasm.getTableOrNull(sourceTableName);
+ if (!sourceTable) {
+ throw SParseException("invalid source table name in table.copy", s);
+ }
+ auto* dest = parseExpression(s[3]);
+ auto* source = parseExpression(s[4]);
+ auto* size = parseExpression(s[5]);
+ return Builder(wasm).makeTableCopy(
+ dest, source, size, destTableName, sourceTableName);
+}
+
// try can be either in the form of try-catch or try-delegate.
// try-catch is written in the folded wast format as
// (try
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index 1d2363be3..0f8facfd5 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -1941,6 +1941,12 @@ void BinaryInstWriter::visitTableFill(TableFill* curr) {
o << U32LEB(parent.getTableIndex(curr->table));
}
+void BinaryInstWriter::visitTableCopy(TableCopy* curr) {
+ o << int8_t(BinaryConsts::MiscPrefix) << U32LEB(BinaryConsts::TableCopy);
+ o << U32LEB(parent.getTableIndex(curr->destTable));
+ o << U32LEB(parent.getTableIndex(curr->sourceTable));
+}
+
void BinaryInstWriter::visitTry(Try* curr) {
breakStack.push_back(curr->name);
o << int8_t(BinaryConsts::Try);
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
index cd90e767e..68d1f786d 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -441,6 +441,7 @@ public:
void visitTableSize(TableSize* curr);
void visitTableGrow(TableGrow* curr);
void visitTableFill(TableFill* curr);
+ void visitTableCopy(TableCopy* curr);
void noteDelegate(Name name, Expression* curr);
void noteRethrow(Name name, Expression* curr);
void visitTry(Try* curr);
@@ -2315,6 +2316,27 @@ void FunctionValidator::visitTableFill(TableFill* curr) {
curr->size->type, Type(Type::i32), curr, "table.fill size must be i32");
}
+void FunctionValidator::visitTableCopy(TableCopy* curr) {
+ shouldBeTrue(getModule()->features.hasBulkMemory(),
+ curr,
+ "table.copy requires bulk-memory [--enable-bulk-memory]");
+ auto* sourceTable = getModule()->getTableOrNull(curr->sourceTable);
+ auto* destTable = getModule()->getTableOrNull(curr->destTable);
+ if (shouldBeTrue(!!sourceTable, curr, "table.copy source table must exist") &&
+ shouldBeTrue(!!destTable, curr, "table.copy dest table must exist")) {
+ shouldBeSubType(sourceTable->type,
+ destTable->type,
+ curr,
+ "table.copy source must have right type for dest");
+ }
+ shouldBeEqualOrFirstIsUnreachable(
+ curr->dest->type, Type(Type::i32), curr, "table.copy dest must be i32");
+ shouldBeEqualOrFirstIsUnreachable(
+ curr->source->type, Type(Type::i32), curr, "table.copy source must be i32");
+ shouldBeEqualOrFirstIsUnreachable(
+ curr->size->type, Type(Type::i32), curr, "table.copy size must be i32");
+}
+
void FunctionValidator::noteDelegate(Name name, Expression* curr) {
if (name != DELEGATE_CALLER_TARGET) {
shouldBeTrue(delegateTargetNames.count(name) != 0,
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
index fef613cd2..24479c1cf 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -866,6 +866,14 @@ void TableFill::finalize() {
}
}
+void TableCopy::finalize() {
+ type = Type::none;
+ if (dest->type == Type::unreachable || source->type == Type::unreachable ||
+ size->type == Type::unreachable) {
+ type = Type::unreachable;
+ }
+}
+
void Try::finalize() {
// If none of the component bodies' type is a supertype of the others, assume
// the current type is already correct. TODO: Calculate a proper LUB.
diff --git a/src/wasm2js.h b/src/wasm2js.h
index e9090d756..4aef8c378 100644
--- a/src/wasm2js.h
+++ b/src/wasm2js.h
@@ -2255,6 +2255,10 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m,
unimplemented(curr);
WASM_UNREACHABLE("unimp");
}
+ Ref visitTableCopy(TableCopy* curr) {
+ unimplemented(curr);
+ WASM_UNREACHABLE("unimp");
+ }
Ref visitTry(Try* curr) {
unimplemented(curr);
WASM_UNREACHABLE("unimp");
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-06 02:56:08 +0000