[lld][WebAssembly] Handle 4gb max memories

[tlively]

Summary

A previous change (53211a) had updated the argument parsing to handle
large max memories, but 4294967296 would still wrap to zero after the
options were parsed. This change updates the configuration to use a
64-bit integer to store the max memory to avoid that overflow.

[sbc100]

Do we want have this behind some kind of feature bit eventually?

[tlively]

In D77437#1960953, @sbc100 wrote:

Do we want have this behind some kind of feature bit eventually?

Hmm, that seems unnecessary because the user already has to explicitly opt in to their preferred max memory size. I should probably add validation that the max is no more than 4gb for now, though.

[tlively]

• Add error checking and make zStackSize 64-bit too

[tlively]

@sbc100 if you could take a look at the new error handling too, that would be great

[majnemer]

lld/wasm/Writer.cpp

290

Should this be 4294967295?

305

Ditto.

[tlively]

lld/wasm/Writer.cpp

290

No, we want to allow exactly 2^32 but nothing more. The highest possible index into a 4GB memory is 4294967295, but the size is still 4GB exactly.

[sbc100]

still lgtm

lld/test/wasm/large-memory.test

 RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.o
 
 ; Verify we can parse large integers such as when we ask for 2G of total
 ; memory.
-RUN: wasm-ld %t.o -o %t.wasm --max-memory=2147483648
+RUN: wasm-ld %t.o -o %t1.wasm --max-memory=2147483648
+RUN: obj2yaml %t1.wasm | FileCheck %s --check-prefixes=CHECK,CHECK-2G
+
+; And also 4G of total memory
+RUN: wasm-ld %t.o -o %t2.wasm --max-memory=4294967296
+RUN: obj2yaml %t2.wasm | FileCheck %s --check-prefixes=CHECK,CHECK-4G
+
+CHECK:      - Type:            MEMORY
+CHECK-NEXT:   Memories:
+CHECK-NEXT:     - Flags:           [ HAS_MAX ]
+CHECK-NEXT:       Initial:         0x00000002
+CHECK-2G-NEXT:    Maximum:         0x00008000
+CHECK-4G-NEXT:    Maximum:         0x00010000
+
+; Test error for more than 4G of memory
+RUN: not wasm-ld %t.o -o %t3.wasm --initial-memory=4295032832 2>&1 | FileCheck %s --check-prefix INIT-ERROR
+RUN: not wasm-ld %t.o -o %t4.wasm --max-memory=4295032832 2>&1 | FileCheck %s --check-prefix MAX-ERROR
+
+INIT-ERROR: initial memory too large, cannot be greater than 4294967296
+MAX-ERROR: maximum memory too large, cannot be greater than 4294967296

lld/wasm/Config.h

struct Configuration {
   bool printGcSections;
   bool relocatable;
   bool saveTemps;
   bool shared;
   bool stripAll;
   bool stripDebug;
   bool stackFirst;
   bool trace;
-  uint32_t globalBase;
-  uint32_t initialMemory;
-  uint32_t maxMemory;
-  uint32_t zStackSize;
+  uint64_t globalBase;
+  uint64_t initialMemory;
+  uint64_t maxMemory;
+  uint64_t zStackSize;
   unsigned ltoPartitions;
   unsigned ltoo;
   unsigned optimize;
   llvm::StringRef thinLTOJobs;
 
   llvm::StringRef entry;
   llvm::StringRef outputFile;
   llvm::StringRef thinLTOCacheDir;

lld/wasm/Writer.cpp

 //  - explicit stack (Config->ZStackSize)
 //  - heap start / unallocated
 //
 // The --stack-first option means that stack is placed before any static data.
 // This can be useful since it means that stack overflow traps immediately
 // rather than overwriting global data, but also increases code size since all
 // static data loads and stores requires larger offsets.
 void Writer::layoutMemory() {
-  uint32_t memoryPtr = 0;
+  uint64_t memoryPtr = 0;
 
   auto placeStack = [&]() {
     if (config->relocatable || config->isPic)
       return;
     memoryPtr = alignTo(memoryPtr, stackAlignment);
     if (config->zStackSize != alignTo(config->zStackSize, stackAlignment))
       error("stack size must be " + Twine(stackAlignment) + "-byte aligned");
     log("mem: stack size  = " + Twine(config->zStackSize));
void Writer::layoutMemory() {
   } else {
     memoryPtr = config->globalBase;
     log("mem: global base = " + Twine(config->globalBase));
   }
 
   if (WasmSym::globalBase)
     WasmSym::globalBase->setVirtualAddress(memoryPtr);
 
-  uint32_t dataStart = memoryPtr;
+  uint64_t dataStart = memoryPtr;
 
   // Arbitrarily set __dso_handle handle to point to the start of the data
   // segments.
   if (WasmSym::dsoHandle)
     WasmSym::dsoHandle->setVirtualAddress(dataStart);
 
   out.dylinkSec->memAlign = 0;
   for (OutputSegment *seg : segments) {
void Writer::layoutMemory() {
   if (WasmSym::heapBase)
     WasmSym::heapBase->setVirtualAddress(memoryPtr);
 
   if (config->initialMemory != 0) {
     if (config->initialMemory != alignTo(config->initialMemory, WasmPageSize))
       error("initial memory must be " + Twine(WasmPageSize) + "-byte aligned");
     if (memoryPtr > config->initialMemory)
       error("initial memory too small, " + Twine(memoryPtr) + " bytes needed");
-    else
-      memoryPtr = config->initialMemory;
+    if (config->initialMemory > (1ULL << 32))
+      error("initial memory too large, cannot be greater than 4294967296");
   }
   out.dylinkSec->memSize = memoryPtr;
   out.memorySec->numMemoryPages =
       alignTo(memoryPtr, WasmPageSize) / WasmPageSize;
   log("mem: total pages = " + Twine(out.memorySec->numMemoryPages));
 
   // Check max if explicitly supplied or required by shared memory
   if (config->maxMemory != 0 || config->sharedMemory) {
     if (config->maxMemory != alignTo(config->maxMemory, WasmPageSize))
       error("maximum memory must be " + Twine(WasmPageSize) + "-byte aligned");
     if (memoryPtr > config->maxMemory)
       error("maximum memory too small, " + Twine(memoryPtr) + " bytes needed");
+    if (config->maxMemory > (1ULL << 32))
+      error("maximum memory too large, cannot be greater than 4294967296");
     out.memorySec->maxMemoryPages = config->maxMemory / WasmPageSize;
     log("mem: max pages   = " + Twine(out.memorySec->maxMemoryPages));
   }
 }
 
 void Writer::addSection(OutputSection *sec) {
   if (!sec->isNeeded())
     return;