Skip to content

Commit 18ba061

Browse files
dschuffdschuff
authored
Handle constant offsets larger than 4G in memory64-lowering (#8316)
If memory instructions have constant offsets greater than the maxiumum size of a 32-bit memory, they become invalid when the memory becomes a 32-bit memory. In this case the memory operation can never succeed, and if the operation was legtimate in the first place (rather than e.g. being the result of an optimization that took advantage of UB in C), then the program cannot be correctly lowered. So in any case it is better to trap if the instruction is actually executed. So this change replaces memory operations with large constant offsets with an unreachable, and hoists any child operations into a block that runs before it.
1 parent 916c4da commit 18ba061

2 files changed

Lines changed: 167 additions & 15 deletions

File tree

‎src/passes/Memory64Lowering.cpp‎

Lines changed: 33 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,8 @@
2222

2323
#include "ir/bits.h"
2424
#include "ir/import-utils.h"
25+
#include "ir/localize.h"
26+
#include "ir/utils.h"
2527
#include "pass.h"
2628
#include "wasm-builder.h"
2729
#include "wasm.h"
@@ -34,8 +36,12 @@ static Name MEMORY_BASE32("__memory_base32");
3436
static Name TABLE_BASE("__table_base");
3537
static Name TABLE_BASE32("__table_base32");
3638

39+
static const Address k32GLimit(1ULL << 32);
40+
3741
struct Memory64Lowering : public WalkerPass<PostWalker<Memory64Lowering>> {
3842

43+
bool refinalize = false;
44+
3945
void wrapAddress64(Expression*& ptr,
4046
Name memoryOrTableName,
4147
bool isTable = false) {
@@ -83,14 +89,27 @@ struct Memory64Lowering : public WalkerPass<PostWalker<Memory64Lowering>> {
8389
return extendAddress64(ptr, tableName, true);
8490
}
8591

86-
void visitLoad(Load* curr) { wrapAddress64(curr->ptr, curr->memory); }
92+
template<typename T> void visitMemoryAccess(T* curr) {
93+
if (curr->offset < k32GLimit) {
94+
return wrapAddress64(curr->ptr, curr->memory);
95+
}
96+
Block* b =
97+
ChildLocalizer(curr, getFunction(), *getModule(), getPassOptions())
98+
.getChildrenReplacement();
99+
b->list.push_back(Builder(*getModule()).makeUnreachable());
100+
b->type = Type::unreachable;
101+
replaceCurrent(b);
102+
refinalize = true;
103+
}
104+
105+
void visitLoad(Load* curr) { visitMemoryAccess(curr); }
87106

88-
void visitStore(Store* curr) { wrapAddress64(curr->ptr, curr->memory); }
107+
void visitStore(Store* curr) { visitMemoryAccess(curr); }
89108

90-
void visitSIMDLoad(SIMDLoad* curr) { wrapAddress64(curr->ptr, curr->memory); }
109+
void visitSIMDLoad(SIMDLoad* curr) { visitMemoryAccess(curr); }
91110

92111
void visitSIMDLoadStoreLane(SIMDLoadStoreLane* curr) {
93-
wrapAddress64(curr->ptr, curr->memory);
112+
visitMemoryAccess(curr);
94113
}
95114

96115
void visitMemorySize(MemorySize* curr) {
@@ -154,20 +173,19 @@ struct Memory64Lowering : public WalkerPass<PostWalker<Memory64Lowering>> {
154173
wrapAddress64(curr->size, curr->destMemory);
155174
}
156175

157-
void visitAtomicRMW(AtomicRMW* curr) {
158-
wrapAddress64(curr->ptr, curr->memory);
159-
}
176+
void visitAtomicRMW(AtomicRMW* curr) { visitMemoryAccess(curr); }
160177

161-
void visitAtomicCmpxchg(AtomicCmpxchg* curr) {
162-
wrapAddress64(curr->ptr, curr->memory);
163-
}
178+
void visitAtomicCmpxchg(AtomicCmpxchg* curr) { visitMemoryAccess(curr); }
164179

165-
void visitAtomicWait(AtomicWait* curr) {
166-
wrapAddress64(curr->ptr, curr->memory);
167-
}
180+
void visitAtomicWait(AtomicWait* curr) { visitMemoryAccess(curr); }
168181

169-
void visitAtomicNotify(AtomicNotify* curr) {
170-
wrapAddress64(curr->ptr, curr->memory);
182+
void visitAtomicNotify(AtomicNotify* curr) { visitMemoryAccess(curr); }
183+
184+
void visitFunction(Function* func) {
185+
if (refinalize) {
186+
ReFinalize().walkFunctionInModule(func, getModule());
187+
refinalize = false;
188+
}
171189
}
172190

173191
void visitDataSegment(DataSegment* segment) {

‎test/lit/passes/memory64-lowering.wast‎

Lines changed: 134 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -440,3 +440,137 @@
440440
(table.init $t64 $elem64 (i64.const 0) (i32.const 5) (i32.const 10))
441441
)
442442
)
443+
444+
(module
445+
(memory i64 1 1)
446+
447+
;; CHECK: (type $0 (func (param i64 v128)))
448+
449+
;; CHECK: (type $1 (func (param i64) (result i32)))
450+
451+
;; CHECK: (type $2 (func (param i64 i32)))
452+
453+
;; CHECK: (type $3 (func (param i64)))
454+
455+
;; CHECK: (memory $0 1 1)
456+
457+
;; CHECK: (func $test_large_offsets (param $ptr i64) (result i32)
458+
;; CHECK-NEXT: (unreachable)
459+
;; CHECK-NEXT: )
460+
(func $test_large_offsets (param $ptr i64) (result i32)
461+
(i32.load offset=4294967297 (local.get $ptr))
462+
)
463+
464+
;; CHECK: (func $test_store_large_offset (param $ptr i64) (param $val i32)
465+
;; CHECK-NEXT: (unreachable)
466+
;; CHECK-NEXT: )
467+
(func $test_store_large_offset (param $ptr i64) (param $val i32)
468+
(i32.store offset=4294967296 (local.get $ptr) (local.get $val))
469+
)
470+
471+
;; CHECK: (func $test_simd_load_large_offset (param $ptr i64)
472+
;; CHECK-NEXT: (drop
473+
;; CHECK-NEXT: (block
474+
;; CHECK-NEXT: (unreachable)
475+
;; CHECK-NEXT: )
476+
;; CHECK-NEXT: )
477+
;; CHECK-NEXT: )
478+
(func $test_simd_load_large_offset (param $ptr i64)
479+
(drop (v128.load offset=4294967296 (local.get $ptr)))
480+
)
481+
482+
;; CHECK: (func $test_simd_load_lane_large_offset (param $ptr i64) (param $val v128)
483+
;; CHECK-NEXT: (drop
484+
;; CHECK-NEXT: (block
485+
;; CHECK-NEXT: (unreachable)
486+
;; CHECK-NEXT: )
487+
;; CHECK-NEXT: )
488+
;; CHECK-NEXT: )
489+
(func $test_simd_load_lane_large_offset (param $ptr i64) (param $val v128)
490+
(drop (v128.load8_lane offset=4294967296 0 (local.get $ptr) (local.get $val)))
491+
)
492+
493+
;; CHECK: (func $test_simd_store_lane_large_offset (param $ptr i64) (param $val v128)
494+
;; CHECK-NEXT: (unreachable)
495+
;; CHECK-NEXT: )
496+
(func $test_simd_store_lane_large_offset (param $ptr i64) (param $val v128)
497+
(v128.store8_lane offset=4294967296 0 (local.get $ptr) (local.get $val))
498+
)
499+
)
500+
501+
(module
502+
;; CHECK: (type $0 (func (param i64 i32)))
503+
504+
;; CHECK: (type $1 (func (param i64 i32 i32)))
505+
506+
;; CHECK: (type $2 (func (param i64 i32 i64)))
507+
508+
;; CHECK: (type $3 (func (param i64) (result i32)))
509+
510+
;; CHECK: (memory $0 1 1)
511+
(memory $0 i64 1 1)
512+
513+
;; CHECK: (func $test_atomic_rmw_large_offset (param $ptr i64) (param $val i32)
514+
;; CHECK-NEXT: (drop
515+
;; CHECK-NEXT: (block
516+
;; CHECK-NEXT: (unreachable)
517+
;; CHECK-NEXT: )
518+
;; CHECK-NEXT: )
519+
;; CHECK-NEXT: )
520+
(func $test_atomic_rmw_large_offset (param $ptr i64) (param $val i32)
521+
(drop (i32.atomic.rmw.add offset=4294967296 (local.get $ptr) (local.get $val)))
522+
)
523+
524+
;; CHECK: (func $test_atomic_cmpxchg_large_offset (param $ptr i64) (param $exp i32) (param $new i32)
525+
;; CHECK-NEXT: (drop
526+
;; CHECK-NEXT: (block
527+
;; CHECK-NEXT: (unreachable)
528+
;; CHECK-NEXT: )
529+
;; CHECK-NEXT: )
530+
;; CHECK-NEXT: )
531+
(func $test_atomic_cmpxchg_large_offset (param $ptr i64) (param $exp i32) (param $new i32)
532+
(drop (i32.atomic.rmw.cmpxchg offset=4294967296 (local.get $ptr) (local.get $exp) (local.get $new)))
533+
)
534+
535+
;; CHECK: (func $test_atomic_wait_large_offset (param $ptr i64) (param $exp i32) (param $timeout i64)
536+
;; CHECK-NEXT: (drop
537+
;; CHECK-NEXT: (block
538+
;; CHECK-NEXT: (unreachable)
539+
;; CHECK-NEXT: )
540+
;; CHECK-NEXT: )
541+
;; CHECK-NEXT: )
542+
(func $test_atomic_wait_large_offset (param $ptr i64) (param $exp i32) (param $timeout i64)
543+
(drop (memory.atomic.wait32 offset=4294967296 (local.get $ptr) (local.get $exp) (local.get $timeout)))
544+
)
545+
546+
;; CHECK: (func $test_atomic_notify_large_offset (param $ptr i64) (param $count i32)
547+
;; CHECK-NEXT: (drop
548+
;; CHECK-NEXT: (block
549+
;; CHECK-NEXT: (unreachable)
550+
;; CHECK-NEXT: )
551+
;; CHECK-NEXT: )
552+
;; CHECK-NEXT: )
553+
(func $test_atomic_notify_large_offset (param $ptr i64) (param $count i32)
554+
(drop (memory.atomic.notify offset=4294967296 (local.get $ptr) (local.get $count)))
555+
)
556+
557+
;; CHECK: (func $test_large_offsets_effect (param $ptr i64) (result i32)
558+
;; CHECK-NEXT: (local $1 i64)
559+
;; CHECK-NEXT: (local.set $1
560+
;; CHECK-NEXT: (i64.div_s
561+
;; CHECK-NEXT: (i64.const 1337)
562+
;; CHECK-NEXT: (local.get $ptr)
563+
;; CHECK-NEXT: )
564+
;; CHECK-NEXT: )
565+
;; CHECK-NEXT: (unreachable)
566+
;; CHECK-NEXT: )
567+
(func $test_large_offsets_effect (param $ptr i64) (result i32)
568+
(i32.load offset=4294967297
569+
;; This might trap, and must be kept around.
570+
(i64.div_s
571+
(i64.const 1337)
572+
(local.get $ptr)
573+
)
574+
)
575+
)
576+
)

0 commit comments

Comments
 (0)