[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

291

Should this be 4294967295?

304

Ditto.

[tlively]

lld/wasm/Writer.cpp

291

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

lld/wasm/Config.h

 //===- Config.h -------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
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;
+  uint64_t globalBase;
+  uint64_t initialMemory;
+  uint64_t maxMemory;
   uint32_t zStackSize;
   unsigned ltoPartitions;
   unsigned ltoo;
   unsigned optimize;
   llvm::StringRef thinLTOJobs;
 
   llvm::StringRef entry;
   llvm::StringRef outputFile;

lld/wasm/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 //  - 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 (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;
   }
   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");
     out.memorySec->maxMemoryPages = config->maxMemory / WasmPageSize;
     log("mem: max pages   = " + Twine(out.memorySec->maxMemoryPages));
   }
 }
 
 void Writer::addSection(OutputSection *sec) {
   if (!sec->isNeeded())
     return;
   log("addSection: " + toString(*sec));
   sec->sectionIndex = outputSections.size();