diff --git a/CHANGELOG.md b/CHANGELOG.md index f39a79773e4..458fefd10bd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,15 @@ full changeset diff at the end of each section. Current Trunk ------------- + - Rename `MemorySegment` functions to `DataSegment` in the c and js apis + - Rename `BinaryenGetNumMemorySegments` to `BinaryenGetNumDataSegments` in c api. + - Rename `BinaryenGetMemorySegmentByteOffset` to `BinaryenGetDataSegmentByteOffset` in c api. + - Rename `BinaryenGetMemorySegmentByteLength` to `BinaryenGetDataSegmentByteLength` in c api. + - Rename `BinaryenGetMemorySegmentPassive` to `BinaryenGetDataSegmentPassive` in c api. + - Rename `BinaryenCopyMemorySegmentData` to `BinaryenCopyDataSegmentData` in c api. + - Rename `module.getNumMemorySegments` to `module.getNumDataSegments` in js api. + - Rename `module.getMemorySegmentInfo` to `module.getDataSegmentInfo` in js api. + v129 ---- diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp index d7dcb8224f0..e82c9bfd89e 100644 --- a/src/binaryen-c.cpp +++ b/src/binaryen-c.cpp @@ -5489,7 +5489,7 @@ void BinaryenSetMemory(BinaryenModuleRef module, // Memory segments -uint32_t BinaryenGetNumMemorySegments(BinaryenModuleRef module) { +uint32_t BinaryenGetNumDataSegments(BinaryenModuleRef module) { return ((Module*)module)->dataSegments.size(); } BinaryenDataSegmentRef BinaryenGetDataSegment(BinaryenModuleRef module, @@ -5507,8 +5507,8 @@ BinaryenDataSegmentRef BinaryenGetDataSegmentByIndex(BinaryenModuleRef module, const char* BinaryenDataSegmentGetName(BinaryenDataSegmentRef segment) { return ((DataSegment*)segment)->name.str.data(); } -uint32_t BinaryenGetMemorySegmentByteOffset(BinaryenModuleRef module, - BinaryenDataSegmentRef segment) { +uint32_t BinaryenGetDataSegmentByteOffset(BinaryenModuleRef module, + BinaryenDataSegmentRef segment) { auto* wasm = (Module*)module; auto globalOffset = [&](const Expression* const& expr, @@ -5625,14 +5625,13 @@ bool BinaryenMemoryIs64(BinaryenModuleRef module, const char* name) { } return memory->is64(); } -size_t BinaryenGetMemorySegmentByteLength(BinaryenDataSegmentRef segment) { +size_t BinaryenGetDataSegmentByteLength(BinaryenDataSegmentRef segment) { return ((DataSegment*)segment)->data.size(); } -bool BinaryenGetMemorySegmentPassive(BinaryenDataSegmentRef segment) { +bool BinaryenGetDataSegmentPassive(BinaryenDataSegmentRef segment) { return ((DataSegment*)segment)->isPassive; } -void BinaryenCopyMemorySegmentData(BinaryenDataSegmentRef segment, - char* buffer) { +void BinaryenCopyDataSegmentData(BinaryenDataSegmentRef segment, char* buffer) { std::copy(((DataSegment*)segment)->data.cbegin(), ((DataSegment*)segment)->data.cend(), buffer); diff --git a/src/binaryen-c.h b/src/binaryen-c.h index 63a8020e095..2e94d372296 100644 --- a/src/binaryen-c.h +++ b/src/binaryen-c.h @@ -3003,25 +3003,24 @@ BINARYEN_API bool BinaryenMemoryIsShared(BinaryenModuleRef module, BINARYEN_API bool BinaryenMemoryIs64(BinaryenModuleRef module, const char* name); -// Memory segments. Query utilities. +// Data segments. Query utilities. BINARYEN_REF(DataSegment); -BINARYEN_API uint32_t BinaryenGetNumMemorySegments(BinaryenModuleRef module); +BINARYEN_API uint32_t BinaryenGetNumDataSegments(BinaryenModuleRef module); BINARYEN_API BinaryenDataSegmentRef BinaryenGetDataSegment(BinaryenModuleRef module, const char* segmentName); BINARYEN_API BinaryenDataSegmentRef BinaryenGetDataSegmentByIndex(BinaryenModuleRef module, BinaryenIndex index); BINARYEN_API const char* BinaryenDataSegmentGetName(BinaryenDataSegmentRef segment); -BINARYEN_API uint32_t BinaryenGetMemorySegmentByteOffset( +BINARYEN_API uint32_t BinaryenGetDataSegmentByteOffset( BinaryenModuleRef module, BinaryenDataSegmentRef segment); BINARYEN_API size_t -BinaryenGetMemorySegmentByteLength(BinaryenDataSegmentRef segment); -BINARYEN_API bool -BinaryenGetMemorySegmentPassive(BinaryenDataSegmentRef segment); -BINARYEN_API void BinaryenCopyMemorySegmentData(BinaryenDataSegmentRef segment, - char* buffer); +BinaryenGetDataSegmentByteLength(BinaryenDataSegmentRef segment); +BINARYEN_API bool BinaryenGetDataSegmentPassive(BinaryenDataSegmentRef segment); +BINARYEN_API void BinaryenCopyDataSegmentData(BinaryenDataSegmentRef segment, + char* buffer); BINARYEN_API void BinaryenAddDataSegment(BinaryenModuleRef module, const char* segmentName, const char* memoryName, diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js index d3ac4a2eafa..0044b5e7c36 100644 --- a/src/js/binaryen.js-post.js +++ b/src/js/binaryen.js-post.js @@ -2769,8 +2769,8 @@ function wrapModule(module, self = {}) { return memoryInfo; }); }; - self['getNumMemorySegments'] = function() { - return Module['_BinaryenGetNumMemorySegments'](module); + self['getNumDataSegments'] = function() { + return Module['_BinaryenGetNumDataSegments'](module); }; /** * Gets the data segment with the given name. @@ -2795,9 +2795,9 @@ function wrapModule(module, self = {}) { return Module['_BinaryenGetDataSegmentByIndex'](module, index); }; /** - * Queries information about a memory segment. + * Queries information about a data segment. * - * @param {number} segment - A MemorySegmentRef referring to the memory segment to get information about. + * @param {number} segment - A DataSegmentRef referring to the data segment to get information about. * @returns {Object} An object containing the following fields: * - `name`: The name of the segment. * - `offset`: If the segment is active, the offset expression of the segment. Otherwise, `null`. @@ -2806,19 +2806,19 @@ function wrapModule(module, self = {}) { * * @throws If the given segment reference is invalid. */ - self['getMemorySegmentInfo'] = function(segment) { - const passive = Boolean(Module['_BinaryenGetMemorySegmentPassive'](segment)); + self['getDataSegmentInfo'] = function(segment) { + const passive = Boolean(Module['_BinaryenGetDataSegmentPassive'](segment)); let offset = null; if (!passive) { - offset = Module['_BinaryenGetMemorySegmentByteOffset'](module, segment); + offset = Module['_BinaryenGetDataSegmentByteOffset'](module, segment); } return { 'name': UTF8ToString(Module['_BinaryenDataSegmentGetName'](segment)), 'offset': offset, 'data': (function(){ - const size = Module['_BinaryenGetMemorySegmentByteLength'](segment); + const size = Module['_BinaryenGetDataSegmentByteLength'](segment); const ptr = _malloc(size); - Module['_BinaryenCopyMemorySegmentData'](segment, ptr); + Module['_BinaryenCopyDataSegmentData'](segment, ptr); const res = new Uint8Array(size); res.set(HEAP8.subarray(ptr, ptr + size)); _free(ptr); diff --git a/test/binaryen.js/kitchen-sink.js b/test/binaryen.js/kitchen-sink.js index 7e2b9897dbb..89753393591 100644 --- a/test/binaryen.js/kitchen-sink.js +++ b/test/binaryen.js/kitchen-sink.js @@ -1195,9 +1195,9 @@ function test_for_each() { ], false); assert(module.getDataSegment(expected_names[0]) !== 0); assert(module.getDataSegment("NonExistantSegment") === 0); - for (i = 0; i < module.getNumMemorySegments(); i++) { + for (i = 0; i < module.getNumDataSegments(); i++) { var segment = module.getDataSegmentByIndex(i); - var info = module.getMemorySegmentInfo(segment); + var info = module.getDataSegmentInfo(segment); assert(expected_names[i] === info.name); assert(expected_offsets[i] === info.offset); var data8 = new Uint8Array(info.data); diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c index 726ff00bf55..225e5feef58 100644 --- a/test/example/c-api-kitchen-sink.c +++ b/test/example/c-api-kitchen-sink.c @@ -2021,16 +2021,16 @@ void test_for_each() { makeInt32(module, expected_offsets[1])); assert(BinaryenGetDataSegment(module, segmentNames[0]) != NULL); assert(BinaryenGetDataSegment(module, "NonExistentSegment") == NULL); - for (i = 0; i < BinaryenGetNumMemorySegments(module); i++) { + for (i = 0; i < BinaryenGetNumDataSegments(module); i++) { char out[15] = {}; BinaryenDataSegmentRef segment = BinaryenGetDataSegmentByIndex(module, i); assert(segment != NULL); assert(BinaryenDataSegmentGetName(segment) != NULL); - assert(BinaryenGetMemorySegmentByteOffset(module, segment) == + assert(BinaryenGetDataSegmentByteOffset(module, segment) == expected_offsets[i]); - assert(BinaryenGetMemorySegmentByteLength(segment) == segmentSizes[i]); - assert(BinaryenGetMemorySegmentPassive(segment) == segmentPassives[i]); - BinaryenCopyMemorySegmentData(segment, out); + assert(BinaryenGetDataSegmentByteLength(segment) == segmentSizes[i]); + assert(BinaryenGetDataSegmentPassive(segment) == segmentPassives[i]); + BinaryenCopyDataSegmentData(segment, out); assert(0 == strcmp(segmentDatas[i], out)); } }