Skip to content

Commit 661c8b2

Browse files
sbc100sbc100
committed
[Wasm64] Fix embind with addresses over 4gb
Fixes: #19968
1 parent 8a2f1ab commit 661c8b2

File tree

12 files changed

+125
-105
lines changed

12 files changed

+125
-105
lines changed

‎.circleci/config.yml‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -619,6 +619,7 @@ jobs:
619619
wasm64_4gb.test_hello_world
620620
wasm64_4gb.test_em_asm
621621
wasm64_4gb.test_async_main
622+
wasm64_4gb.*embind*
622623
core_2gb.test_em_asm
623624
wasm64l.test_bigswitch
624625
other.test_memory64_proxies

‎src/embind/embind.js‎

Lines changed: 46 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,7 @@ var LibraryEmbind = {
3434
$PureVirtualError__postset: "PureVirtualError = Module['PureVirtualError'] = extendError(Error, 'PureVirtualError');",
3535
$PureVirtualError__deps: ['$extendError'],
3636
$PureVirtualError: undefined,
37+
$GenericWireTypeSize: {{{ 2 * POINTER_SIZE }}},
3738

3839
$init_embind__deps: [
3940
'$getInheritedInstanceCount', '$getLiveInheritedInstances',
@@ -274,7 +275,7 @@ var LibraryEmbind = {
274275
});
275276
},
276277

277-
_embind_register_bool__deps: ['$readLatin1String', '$registerType'],
278+
_embind_register_bool__deps: ['$readLatin1String', '$registerType', '$GenericWireTypeSize'],
278279
_embind_register_bool: (rawType, name, trueValue, falseValue) => {
279280
name = readLatin1String(name);
280281
registerType(rawType, {
@@ -287,7 +288,7 @@ var LibraryEmbind = {
287288
'toWireType': function(destructors, o) {
288289
return o ? trueValue : falseValue;
289290
},
290-
'argPackAdvance': 8,
291+
'argPackAdvance': GenericWireTypeSize,
291292
'readValueFromPointer': function(pointer) {
292293
return this['fromWireType'](HEAPU8[pointer]);
293294
},
@@ -300,18 +301,18 @@ var LibraryEmbind = {
300301
// integers are quite common, so generate very specialized functions
301302
switch (width) {
302303
case 1: return signed ?
303-
function readS8FromPointer(pointer) { return HEAP8[pointer]; } :
304-
function readU8FromPointer(pointer) { return HEAPU8[pointer]; };
304+
(pointer) => {{{ makeGetValue('pointer', 0, 'i8') }}} :
305+
(pointer) => {{{ makeGetValue('pointer', 0, 'u8') }}};
305306
case 2: return signed ?
306-
function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } :
307-
function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; };
307+
(pointer) => {{{ makeGetValue('pointer', 0, 'i16') }}} :
308+
(pointer) => {{{ makeGetValue('pointer', 0, 'u16') }}}
308309
case 4: return signed ?
309-
function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } :
310-
function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; };
310+
(pointer) => {{{ makeGetValue('pointer', 0, 'i32') }}} :
311+
(pointer) => {{{ makeGetValue('pointer', 0, 'i32') }}}
311312
#if WASM_BIGINT
312313
case 8: return signed ?
313-
function readS64FromPointer(pointer) { return HEAP64[pointer >> 3]; } :
314-
function readU64FromPointer(pointer) { return HEAPU64[pointer >> 3]; };
314+
(pointer) => {{{ makeGetValue('pointer', 0, 'i64') }}} :
315+
(pointer) => {{{ makeGetValue('pointer', 0, 'u64') }}}
315316
#endif
316317
default:
317318
throw new TypeError(`invalid integer width (${width}): ${name}`);
@@ -321,18 +322,15 @@ var LibraryEmbind = {
321322
$enumReadValueFromPointer__deps: [],
322323
$enumReadValueFromPointer: (name, width, signed) => {
323324
switch (width) {
324-
case 1: return function(pointer) {
325-
var heap = signed ? HEAP8 : HEAPU8;
326-
return this['fromWireType'](heap[pointer]);
327-
};
328-
case 2: return function(pointer) {
329-
var heap = signed ? HEAP16 : HEAPU16;
330-
return this['fromWireType'](heap[pointer >> 1]);
331-
};
332-
case 4: return function(pointer) {
333-
var heap = signed ? HEAP32 : HEAPU32;
334-
return this['fromWireType'](heap[pointer >> 2]);
335-
};
325+
case 1: return signed ?
326+
function(pointer) { return this['fromWireType']({{{ makeGetValue('pointer', 0, 'i8') }}}) } :
327+
function(pointer) { return this['fromWireType']({{{ makeGetValue('pointer', 0, 'u8') }}}) };
328+
case 2: return signed ?
329+
function(pointer) { return this['fromWireType']({{{ makeGetValue('pointer', 0, 'i16') }}}) } :
330+
function(pointer) { return this['fromWireType']({{{ makeGetValue('pointer', 0, 'u16') }}}) };
331+
case 4: return signed ?
332+
function(pointer) { return this['fromWireType']({{{ makeGetValue('pointer', 0, 'i32') }}}) } :
333+
function(pointer) { return this['fromWireType']({{{ makeGetValue('pointer', 0, 'u32') }}}) };
336334
default:
337335
throw new TypeError(`invalid integer width (${width}): ${name}`);
338336
}
@@ -342,10 +340,10 @@ var LibraryEmbind = {
342340
$floatReadValueFromPointer: (name, width) => {
343341
switch (width) {
344342
case 4: return function(pointer) {
345-
return this['fromWireType'](HEAPF32[pointer >> 2]);
343+
return this['fromWireType']({{{ makeGetValue('pointer', 0, 'float') }}});
346344
};
347345
case 8: return function(pointer) {
348-
return this['fromWireType'](HEAPF64[pointer >> 3]);
346+
return this['fromWireType']({{{ makeGetValue('pointer', 0, 'double') }}});
349347
};
350348
default:
351349
throw new TypeError(`invalid float width (${width}): ${name}`);
@@ -401,7 +399,7 @@ var LibraryEmbind = {
401399
name,
402400
'fromWireType': fromWireType,
403401
'toWireType': toWireType,
404-
'argPackAdvance': 8,
402+
'argPackAdvance': GenericWireTypeSize,
405403
'readValueFromPointer': integerReadValueFromPointer(name, size, minRange !== 0),
406404
destructorFunction: null, // This type does not need a destructor
407405
});
@@ -432,7 +430,7 @@ var LibraryEmbind = {
432430
}
433431
return value;
434432
},
435-
'argPackAdvance': 8,
433+
'argPackAdvance': GenericWireTypeSize,
436434
'readValueFromPointer': integerReadValueFromPointer(name, size, !isUnsignedType),
437435
destructorFunction: null, // This type does not need a destructor
438436
});
@@ -460,7 +458,7 @@ var LibraryEmbind = {
460458
// https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue
461459
return value;
462460
},
463-
'argPackAdvance': 8,
461+
'argPackAdvance': GenericWireTypeSize,
464462
'readValueFromPointer': floatReadValueFromPointer(name, size),
465463
destructorFunction: null, // This type does not need a destructor
466464
});
@@ -471,9 +469,13 @@ var LibraryEmbind = {
471469
return this['fromWireType']({{{ makeGetValue('pointer', '0', 'i32') }}});
472470
},
473471

472+
$readPointer: function(pointer) {
473+
return this['fromWireType']({{{ makeGetValue('pointer', '0', '*') }}});
474+
},
475+
474476
_embind_register_std_string__deps: [
475477
'$readLatin1String', '$registerType',
476-
'$simpleReadValueFromPointer', '$throwBindingError',
478+
'$readPointer', '$throwBindingError',
477479
'$stringToUTF8', '$lengthBytesUTF8', 'malloc', 'free'],
478480
_embind_register_std_string: (rawType, name) => {
479481
name = readLatin1String(name);
@@ -566,14 +568,14 @@ var LibraryEmbind = {
566568
}
567569
return base;
568570
},
569-
'argPackAdvance': 8,
570-
'readValueFromPointer': simpleReadValueFromPointer,
571+
'argPackAdvance': GenericWireTypeSize,
572+
'readValueFromPointer': readPointer,
571573
destructorFunction: (ptr) => _free(ptr),
572574
});
573575
},
574576

575577
_embind_register_std_wstring__deps: [
576-
'$readLatin1String', '$registerType', '$simpleReadValueFromPointer',
578+
'$readLatin1String', '$registerType', '$readPointer',
577579
'$UTF16ToString', '$stringToUTF16', '$lengthBytesUTF16',
578580
'$UTF32ToString', '$stringToUTF32', '$lengthBytesUTF32',
579581
],
@@ -597,7 +599,7 @@ var LibraryEmbind = {
597599
name,
598600
'fromWireType': (value) => {
599601
// Code mostly taken from _embind_register_std_string fromWireType
600-
var length = HEAPU32[value >> 2];
602+
var length = {{{ makeGetValue('value', 0, '*') }}};
601603
var HEAP = getHeap();
602604
var str;
603605

@@ -639,7 +641,7 @@ var LibraryEmbind = {
639641
}
640642
return ptr;
641643
},
642-
'argPackAdvance': 8,
644+
'argPackAdvance': GenericWireTypeSize,
643645
'readValueFromPointer': simpleReadValueFromPointer,
644646
destructorFunction: (ptr) => _free(ptr),
645647
});
@@ -658,7 +660,7 @@ var LibraryEmbind = {
658660
return rv;
659661
},
660662
'toWireType': (destructors, value) => Emval.toHandle(value),
661-
'argPackAdvance': 8,
663+
'argPackAdvance': GenericWireTypeSize,
662664
'readValueFromPointer': simpleReadValueFromPointer,
663665
destructorFunction: null, // This type does not need a destructor
664666

@@ -687,18 +689,16 @@ var LibraryEmbind = {
687689
var TA = typeMapping[dataTypeIndex];
688690

689691
function decodeMemoryView(handle) {
690-
handle = handle >> 2;
691-
var heap = HEAPU32;
692-
var size = heap[handle]; // in elements
693-
var data = heap[handle + 1]; // byte offset into emscripten heap
694-
return new TA(heap.buffer, data, size);
692+
var size = {{{ makeGetValue('handle', 0, '*') }}};
693+
var data = {{{ makeGetValue('handle', POINTER_SIZE, '*') }}};
694+
return new TA(HEAP8.buffer, data, size);
695695
}
696696

697697
name = readLatin1String(name);
698698
registerType(rawType, {
699699
name,
700700
'fromWireType': decodeMemoryView,
701-
'argPackAdvance': 8,
701+
'argPackAdvance': GenericWireTypeSize,
702702
'readValueFromPointer': decodeMemoryView,
703703
}, {
704704
ignoreDuplicateRegistrations: true,
@@ -1098,7 +1098,7 @@ var LibraryEmbind = {
10981098
}
10991099
return ptr;
11001100
},
1101-
'argPackAdvance': 8,
1101+
'argPackAdvance': GenericWireTypeSize,
11021102
'readValueFromPointer': simpleReadValueFromPointer,
11031103
destructorFunction: rawDestructor,
11041104
}];
@@ -1210,7 +1210,7 @@ var LibraryEmbind = {
12101210
}
12111211
return ptr;
12121212
},
1213-
'argPackAdvance': 8,
1213+
'argPackAdvance': GenericWireTypeSize,
12141214
'readValueFromPointer': simpleReadValueFromPointer,
12151215
destructorFunction: rawDestructor,
12161216
}];
@@ -1340,14 +1340,14 @@ var LibraryEmbind = {
13401340
},
13411341

13421342
$init_RegisteredPointer__deps: [
1343-
'$simpleReadValueFromPointer',
1343+
'$readPointer',
13441344
'$RegisteredPointer_getPointee', '$RegisteredPointer_destructor',
13451345
'$RegisteredPointer_deleteObject', '$RegisteredPointer_fromWireType'],
13461346
$init_RegisteredPointer: () => {
13471347
RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee;
13481348
RegisteredPointer.prototype.destructor = RegisteredPointer_destructor;
1349-
RegisteredPointer.prototype['argPackAdvance'] = 8;
1350-
RegisteredPointer.prototype['readValueFromPointer'] = simpleReadValueFromPointer;
1349+
RegisteredPointer.prototype['argPackAdvance'] = GenericWireTypeSize;
1350+
RegisteredPointer.prototype['readValueFromPointer'] = readPointer;
13511351
RegisteredPointer.prototype['deleteObject'] = RegisteredPointer_deleteObject;
13521352
RegisteredPointer.prototype['fromWireType'] = RegisteredPointer_fromWireType;
13531353
},
@@ -2379,7 +2379,7 @@ var LibraryEmbind = {
23792379
return this.constructor.values[c];
23802380
},
23812381
'toWireType': (destructors, c) => c.value,
2382-
'argPackAdvance': 8,
2382+
'argPackAdvance': GenericWireTypeSize,
23832383
'readValueFromPointer': enumReadValueFromPointer(name, size, isSigned),
23842384
destructorFunction: null,
23852385
});

‎src/library.js‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -159,9 +159,9 @@ addToLibrary({
159159
// it. Returns 1 on success, 0 on error.
160160
$growMemory: (size) => {
161161
var b = wasmMemory.buffer;
162-
var pages = (size - b.byteLength + 65535) >>> 16;
162+
var pages = (size - b.byteLength + {{{ WASM_PAGE_SIZE - 1 }}}) / {{{ WASM_PAGE_SIZE }}};
163163
#if RUNTIME_DEBUG
164-
dbg(`emscripten_resize_heap: ${size} (+${size - b.byteLength} bytes / ${pages} pages)`);
164+
dbg(`growMemory: ${size} (+${size - b.byteLength} bytes / ${pages} pages)`);
165165
#endif
166166
#if MEMORYPROFILER
167167
var oldHeapSize = b.byteLength;
@@ -249,7 +249,7 @@ addToLibrary({
249249
var maxHeapSize = getHeapMax();
250250
if (requestedSize > maxHeapSize) {
251251
#if ASSERTIONS
252-
err(`Cannot enlarge memory, asked to go up to ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);
252+
err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);
253253
#endif
254254
#if ABORTING_MALLOC
255255
abortOnCannotGrowMemory(requestedSize);
@@ -693,7 +693,7 @@ addToLibrary({
693693
// size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr);
694694
// http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html
695695

696-
var tm_zone = {{{ makeGetValue('tm', C_STRUCTS.tm.tm_zone, 'i32') }}};
696+
var tm_zone = {{{ makeGetValue('tm', C_STRUCTS.tm.tm_zone, '*') }}};
697697

698698
var date = {
699699
tm_sec: {{{ makeGetValue('tm', C_STRUCTS.tm.tm_sec, 'i32') }}},

‎src/library_fs_shared.js‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -133,7 +133,7 @@ addToLibrary({
133133
var fd = process.stdin.fd;
134134

135135
try {
136-
bytesRead = fs.readSync(fd, buf, 0, BUFSIZE, -1);
136+
bytesRead = fs.readSync(fd, buf, { position: -1 });
137137
} catch(e) {
138138
// Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes,
139139
// reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0.

‎src/library_int53.js‎

Lines changed: 25 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -19,30 +19,32 @@ addToLibrary({
1919
// function $writeI53ToU64(): the implementation would be identical, and it is up to the
2020
// C/C++ side code to interpret the resulting number as signed or unsigned as is desirable.
2121
$writeI53ToI64: (ptr, num) => {
22-
HEAPU32[ptr>>2] = num;
23-
HEAPU32[ptr+4>>2] = (num - HEAPU32[ptr>>2])/4294967296;
22+
{{{ makeSetValue('ptr', 0, 'num', 'i32') }}};
23+
var lower = {{{ makeGetValue('ptr', 0, 'i32') }}};
24+
{{{ makeSetValue('ptr', 4, '(num - lower)/4294967296', 'i32') }}};
2425
#if ASSERTIONS
2526
var deserialized = (num >= 0) ? readI53FromU64(ptr) : readI53FromI64(ptr);
26-
if (deserialized != num) warnOnce('writeI53ToI64() out of range: serialized JS Number ' + num + ' to Wasm heap as bytes lo=' + ptrToString(HEAPU32[ptr>>2]) + ', hi=' + ptrToString(HEAPU32[ptr+4>>2]) + ', which deserializes back to ' + deserialized + ' instead!');
27+
if (deserialized != num) warnOnce(`writeI53ToI64() out of range: serialized JS Number ${num} to Wasm heap as bytes lo=${ptrToString(HEAPU32[ptr/4])}, hi=${ptrToString(HEAPU32[ptr/4+1])}, which deserializes back to ${deserialized} instead!`);
2728
#endif
2829
},
2930

3031
// Same as writeI53ToI64, but if the double precision number does not fit within the
3132
// 64-bit number, the number is clamped to range [-2^63, 2^63-1].
33+
$writeI53ToI64Clamped__deps: ['$writeI53ToI64'],
3234
$writeI53ToI64Clamped: (ptr, num) => {
3335
if (num > 0x7FFFFFFFFFFFFFFF) {
34-
HEAPU32[ptr>>2] = 0xFFFFFFFF;
35-
HEAPU32[ptr+4>>2] = 0x7FFFFFFF;
36+
{{{ makeSetValue('ptr', 0, 0xFFFFFFFF, 'i32') }}};
37+
{{{ makeSetValue('ptr', 4, 0x7FFFFFFF, 'i32') }}};
3638
} else if (num < -0x8000000000000000) {
37-
HEAPU32[ptr>>2] = 0;
38-
HEAPU32[ptr+4>>2] = 0x80000000;
39+
{{{ makeSetValue('ptr', 0, 0, 'i32') }}};
40+
{{{ makeSetValue('ptr', 4, 0x80000000, 'i32') }}};
3941
} else {
40-
HEAPU32[ptr>>2] = num;
41-
HEAPU32[ptr+4>>2] = (num - HEAPU32[ptr>>2])/4294967296;
42+
writeI53ToI64(ptr, num);
4243
}
4344
},
4445

4546
// Like writeI53ToI64, but throws if the passed number is out of range of int64.
47+
$writeI53ToI64__deps: ['$writeI53ToI64'],
4648
$writeI53ToI64Signaling: (ptr, num) => {
4749
if (num > 0x7FFFFFFFFFFFFFFF || num < -0x8000000000000000) {
4850
#if ASSERTIONS
@@ -51,22 +53,26 @@ addToLibrary({
5153
throw 'RangeError:' + num;
5254
#endif
5355
}
54-
HEAPU32[ptr>>2] = num;
55-
HEAPU32[ptr+4>>2] = (num - HEAPU32[ptr>>2])/4294967296;
56+
writeI53ToI64(ptr, num);
5657
},
5758

5859
// Uint64 variant of writeI53ToI64Clamped. Writes the Number to a Uint64 variable on
5960
// the heap, clamping out of range values to range [0, 2^64-1].
61+
$writeI53ToU64Clamped__deps: ['$writeI53ToI64'],
6062
$writeI53ToU64Clamped: (ptr, num) => {
61-
if (num > 0xFFFFFFFFFFFFFFFF) HEAPU32[ptr>>2] = HEAPU32[ptr+4>>2] = 0xFFFFFFFF;
62-
else if (num < 0) HEAPU32[ptr>>2] = HEAPU32[ptr+4>>2] = 0;
63-
else {
64-
HEAPU32[ptr>>2] = num;
65-
HEAPU32[ptr+4>>2] = (num - HEAPU32[ptr>>2])/4294967296;
63+
if (num > 0xFFFFFFFFFFFFFFFF) {
64+
{{{ makeSetValue('ptr', 0, 0xFFFFFFFF, 'i32') }}};
65+
{{{ makeSetValue('ptr', 4, 0xFFFFFFFF, 'i32') }}};
66+
} else if (num < 0) {
67+
{{{ makeSetValue('ptr', 0, 0, 'i32') }}};
68+
{{{ makeSetValue('ptr', 4, 0, 'i32') }}};
69+
} else {
70+
writeI53ToI64(ptr, num);
6671
}
6772
},
6873

6974
// Like writeI53ToI64, but throws if the passed number is out of range of uint64.
75+
$writeI53ToU64Signaling__deps: ['$writeI53ToI64'],
7076
$writeI53ToU64Signaling: (ptr, num) => {
7177
if (num < 0 || num > 0xFFFFFFFFFFFFFFFF) {
7278
#if ASSERTIONS
@@ -75,22 +81,21 @@ addToLibrary({
7581
throw 'RangeError:'+num;
7682
#endif
7783
}
78-
HEAPU32[ptr>>2] = num;
79-
HEAPU32[ptr+4>>2] = (num - HEAPU32[ptr>>2])/4294967296;
84+
writeI53ToI64(ptr, num);
8085
},
8186

8287
// Reads a 64-bit signed integer from the WebAssembly heap and
8388
// converts it to a JavaScript Number, which can represent 53 integer bits precisely.
8489
// TODO: Add $readI53FromI64Signaling() variant.
8590
$readI53FromI64: (ptr) => {
86-
return HEAPU32[ptr>>2] + HEAP32[ptr+4>>2] * 4294967296;
91+
return {{{ makeGetValue('ptr', 0, 'u32') }}} + {{{ makeGetValue('ptr', 4, 'i32') }}} * 4294967296;
8792
},
8893

8994
// Reads a 64-bit unsigned integer from the WebAssembly heap and
9095
// converts it to a JavaScript Number, which can represent 53 integer bits precisely.
9196
// TODO: Add $readI53FromU64Signaling() variant.
9297
$readI53FromU64: (ptr) => {
93-
return HEAPU32[ptr>>2] + HEAPU32[ptr+4>>2] * 4294967296;
98+
return {{{ makeGetValue('ptr', 0, 'u32') }}} + {{{ makeGetValue('ptr', 4, 'u32') }}} * 4294967296;
9499
},
95100

96101
// Converts the given signed 32-bit low-high pair to a JavaScript Number that

0 commit comments

Comments
 (0)