[WebAssembly] Factor out WasmTableType in binary format

[wingo]

Summary

This commit factors out a WasmTableType definition from WasmTable, as is the case for WasmGlobal and other data types. Also add support for extracting the SymbolName for a table from the linking section's symbol table.

[wingo]

A refactor harmonizing treatment of tables, relative to other kinds of definitions. NFC; I tested codegen, MC, and lld wasm tests.

[sbc100]

Awesome!

llvm/lib/Object/WasmObjectFile.cpp

600

Looks like you also added support for table names.. Maybe mention that in the description?

llvm/tools/obj2yaml/wasm2yaml.cpp

237

Hmm.. is this true for GlobalImport and EventImport too? It looks like none of them set Index.

It it worth switching Im.TableImport to be of type TypeType instead of `Table? Maybe that comes latest when the FIXME is addressed?

[wingo]

I guess I should ask for commit rights so I can land after approval; would you be OK sponsoring my request, Sam? In the meantime if you would like to land this one that would be grand :)

llvm/tools/obj2yaml/wasm2yaml.cpp

237

Yeah this is true of GlobalImport and EventImport also. Agreed that it does make sense here to just store a TableType; can fix in a followup.

[sbc100]

I'm seeing a lot of tests fail. For example just the MC tests:

Failed Tests (28):
  LLVM :: MC/WebAssembly/array-fill.ll
  LLVM :: MC/WebAssembly/assembler-binary.ll
  LLVM :: MC/WebAssembly/bss.ll
  LLVM :: MC/WebAssembly/comdat.ll
  LLVM :: MC/WebAssembly/data-section.s
  LLVM :: MC/WebAssembly/event-section.ll
  LLVM :: MC/WebAssembly/explicit-sections.ll
  LLVM :: MC/WebAssembly/export-name.s
  LLVM :: MC/WebAssembly/external-data.ll
  LLVM :: MC/WebAssembly/external-func-address.ll
  LLVM :: MC/WebAssembly/externref.s
  LLVM :: MC/WebAssembly/function-sections.ll
  LLVM :: MC/WebAssembly/global-ctor-dtor.ll
  LLVM :: MC/WebAssembly/globals.s
  LLVM :: MC/WebAssembly/import-module.s
  LLVM :: MC/WebAssembly/libcall.ll
  LLVM :: MC/WebAssembly/offset.ll
  LLVM :: MC/WebAssembly/reloc-pic.s
  LLVM :: MC/WebAssembly/stack-ptr.ll
  LLVM :: MC/WebAssembly/tables.s
  LLVM :: MC/WebAssembly/tls.s
  LLVM :: MC/WebAssembly/type-index.s
  LLVM :: MC/WebAssembly/types.ll
  LLVM :: MC/WebAssembly/unnamed-data.ll
  LLVM :: MC/WebAssembly/visibility.ll
  LLVM :: MC/WebAssembly/wasm64.s
  LLVM :: MC/WebAssembly/weak-alias.s
  LLVM :: MC/WebAssembly/weak.s

Looks like something to do with objectyaml:

FAIL: LLVM :: MC/WebAssembly/weak.s (1 of 1)
******************** TEST 'LLVM :: MC/WebAssembly/weak.s' FAILED ********************
Script:
--
: 'RUN: at line 1';   /usr/local/google/home/sbc/dev/wasm/llvm-build/bin/llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -o /usr/local/google/home/sbc/dev/wasm/llvm-build/test/MC/WebAssembly/Output/weak.s.tmp.o < /usr/local/google/home/sbc/dev/wasm/llvm-project/llvm/test/MC/WebAssembly/weak.s
: 'RUN: at line 2';   /usr/local/google/home/sbc/dev/wasm/llvm-build/bin/obj2yaml /usr/local/google/home/sbc/dev/wasm/llvm-build/test/MC/WebAssembly/Output/weak.s.tmp.o | /usr/local/google/home/sbc/dev/wasm/llvm-build/bin/FileCheck /usr/local/google/home/sbc/dev/wasm/llvm-project/llvm/test/MC/WebAssembly/weak.s
--
Exit Code: 2

Command Output (stderr):
--
bad runtime enum value
UNREACHABLE executed at /usr/local/google/home/sbc/dev/wasm/llvm-project/llvm/lib/Support/YAMLTraits.cpp:655!
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.
Stack dump:
0.	Program arguments: /usr/local/google/home/sbc/dev/wasm/llvm-build/bin/obj2yaml /usr/local/google/home/sbc/dev/wasm/llvm-build/test/MC/WebAssembly/Output/weak.s.tmp.o
 #0 0x00007fdcbe7fbb83 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/../lib/libLLVMSupport.so.12git+0x193b83)
 #1 0x00007fdcbe7f99ae llvm::sys::RunSignalHandlers() (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/../lib/libLLVMSupport.so.12git+0x1919ae)
 #2 0x00007fdcbe7fc045 SignalHandler(int) (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/../lib/libLLVMSupport.so.12git+0x194045)
 #3 0x00007fdcbeabf140 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x14140)
 #4 0x00007fdcbe1b3db1 raise ./signal/../sysdeps/unix/sysv/linux/raise.c:51:1
 #5 0x00007fdcbe19d537 abort ./stdlib/abort.c:81:7
 #6 0x00007fdcbe73c2a1 (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/../lib/libLLVMSupport.so.12git+0xd42a1)
 #7 0x00007fdcbe7d8e91 (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/../lib/libLLVMSupport.so.12git+0x170e91)
 #8 0x00007fdcbec3ae1d llvm::yaml::MappingTraits<llvm::WasmYAML::Table>::mapping(llvm::yaml::IO&, llvm::WasmYAML::Table&) (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/../lib/libLLVMObjectYAML.so.12git+0x134e1d)
 #9 0x00007fdcbec3bc1f llvm::yaml::MappingTraits<llvm::WasmYAML::Import>::mapping(llvm::yaml::IO&, llvm::WasmYAML::Import&) (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/../lib/libLLVMObjectYAML.so.12git+0x135c1f)
#10 0x00007fdcbec3fe4c std::enable_if<has_SequenceTraits<std::vector<llvm::WasmYAML::Import, std::allocator<llvm::WasmYAML::Import> > >::value, void>::type llvm::yaml::yamlize<std::vector<llvm::WasmYAML::Import, std::allocator<llvm::WasmYAML::Import> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::WasmYAML::Import, std::allocator<llvm::WasmYAML::Import> >&, bool, llvm::yaml::EmptyContext&) (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/../lib/libLLVMObjectYAML.so.12git+0x139e4c)
#11 0x00007fdcbec387b5 llvm::yaml::MappingTraits<std::unique_ptr<llvm::WasmYAML::Section, std::default_delete<llvm::WasmYAML::Section> > >::mapping(llvm::yaml::IO&, std::unique_ptr<llvm::WasmYAML::Section, std::default_delete<llvm::WasmYAML::Section> >&) (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/../lib/libLLVMObjectYAML.so.12git+0x1327b5)
#12 0x00007fdcbec42658 std::enable_if<has_SequenceTraits<std::vector<std::unique_ptr<llvm::WasmYAML::Section, std::default_delete<llvm::WasmYAML::Section> >, std::allocator<std::unique_ptr<llvm::WasmYAML::Section, std::default_delete<llvm::WasmYAML::Section> > > > >::value, void>::type llvm::yaml::yamlize<std::vector<std::unique_ptr<llvm::WasmYAML::Section, std::default_delete<llvm::WasmYAML::Section> >, std::allocator<std::unique_ptr<llvm::WasmYAML::Section, std::default_delete<llvm::WasmYAML::Section> > > >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<std::unique_ptr<llvm::WasmYAML::Section, std::default_delete<llvm::WasmYAML::Section> >, std::allocator<std::unique_ptr<llvm::WasmYAML::Section, std::default_delete<llvm::WasmYAML::Section> > > >&, bool, llvm::yaml::EmptyContext&) (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/../lib/libLLVMObjectYAML.so.12git+0x13c658)
#13 0x00007fdcbec37f4e llvm::yaml::MappingTraits<llvm::WasmYAML::Object>::mapping(llvm::yaml::IO&, llvm::WasmYAML::Object&) (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/../lib/libLLVMObjectYAML.so.12git+0x131f4e)
#14 0x000000000047f518 wasm2yaml(llvm::raw_ostream&, llvm::object::WasmObjectFile const&) (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/obj2yaml+0x47f518)
#15 0x00000000004104d5 main (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/obj2yaml+0x4104d5)
#16 0x00007fdcbe19ecca __libc_start_main ./csu/../csu/libc-start.c:308:16
#17 0x000000000040dd2a _start (/usr/local/google/home/sbc/dev/wasm/llvm-build/bin/obj2yaml+0x40dd2a)
FileCheck error: '<stdin>' is empty.
FileCheck command line:  /usr/local/google/home/sbc/dev/wasm/llvm-build/bin/FileCheck /usr/local/google/home/sbc/dev/wasm/llvm-project/llvm/test/MC/WebAssembly/weak.s

[wingo]

Rebase (no conflicts)

[wingo]

In D91849#2414289, @sbc100 wrote:

I'm seeing a lot of tests fail. For example just the MC tests:

Weird. I rebuilt fresh release and debug binaries here and no problem. Just rebased the patch too and also no problem (patch just updated now). No CI errors either AFAICS. What could be wrong?

[sbc100]

Sorry, I think I might have only doing a partial rebuild when I first tried this patch. Seems to work now.arcpatch-D91849_1

[wingo]

thanks!!

lld/wasm/SyntheticSections.cpp

void TableSection::writeBody() {
 
   raw_ostream &os = bodyOutputStream;
   writeUleb128(os, 1, "table count");
   WasmLimits limits;
   if (config->growableTable)
     limits = {0, tableSize, 0};
   else
     limits = {WASM_LIMITS_FLAG_HAS_MAX, tableSize, tableSize};
-  writeTableType(os, WasmTable{0, WASM_TYPE_FUNCREF, limits});
+  writeTableType(os, WasmTableType{WASM_TYPE_FUNCREF, limits});
 }
 
 void MemorySection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   bool hasMax = maxMemoryPages != 0 || config->sharedMemory;
   writeUleb128(os, 1, "memory count");
   unsigned flags = 0;

lld/wasm/WriterUtils.h

 void writeGlobalType(raw_ostream &os, const llvm::wasm::WasmGlobalType &type);
 
 void writeGlobal(raw_ostream &os, const llvm::wasm::WasmGlobal &global);
 
 void writeEventType(raw_ostream &os, const llvm::wasm::WasmEventType &type);
 
 void writeEvent(raw_ostream &os, const llvm::wasm::WasmEvent &event);
 
-void writeTableType(raw_ostream &os, const llvm::wasm::WasmTable &type);
+void writeTableType(raw_ostream &os, const llvm::wasm::WasmTableType &type);
 
 void writeImport(raw_ostream &os, const llvm::wasm::WasmImport &import);
 
 void writeExport(raw_ostream &os, const llvm::wasm::WasmExport &export_);
 
 } // namespace wasm
 
 std::string toString(llvm::wasm::ValType type);
 std::string toString(const llvm::wasm::WasmSignature &sig);
 std::string toString(const llvm::wasm::WasmGlobalType &type);
 std::string toString(const llvm::wasm::WasmEventType &type);
 
 } // namespace lld
 
 #endif // LLD_WASM_WRITERUTILS_H

lld/wasm/WriterUtils.cpp

void writeEventType(raw_ostream &os, const WasmEventType &type) {
   writeUleb128(os, type.Attribute, "event attribute");
   writeUleb128(os, type.SigIndex, "sig index");
 }
 
 void writeEvent(raw_ostream &os, const WasmEvent &event) {
   writeEventType(os, event.Type);
 }
 
-void writeTableType(raw_ostream &os, const llvm::wasm::WasmTable &type) {
+void writeTableType(raw_ostream &os, const WasmTableType &type) {
   writeU8(os, WASM_TYPE_FUNCREF, "table type");
   writeLimits(os, type.Limits);
 }
 
 void writeImport(raw_ostream &os, const WasmImport &import) {
   writeStr(os, import.Module, "import module name");
   writeStr(os, import.Field, "import field name");
   writeU8(os, import.Kind, "import kind");

llvm/include/llvm/BinaryFormat/Wasm.h

 };
 
 struct WasmLimits {
   uint8_t Flags;
   uint64_t Initial;
   uint64_t Maximum;
 };
 
-struct WasmTable {
-  uint32_t Index;
+struct WasmTableType {
   uint8_t ElemType;
   WasmLimits Limits;
 };
 
+struct WasmTable {
+  uint32_t Index;
+  WasmTableType Type;
+  StringRef SymbolName; // from the "linking" section
+};
+
 struct WasmInitExpr {
   uint8_t Opcode;
   union {
     int32_t Int32;
     int64_t Int64;
     uint32_t Float32;
     uint64_t Float64;
     uint32_t Global;

 
 struct WasmImport {
   StringRef Module;
   StringRef Field;
   uint8_t Kind;
   union {
     uint32_t SigIndex;
     WasmGlobalType Global;
-    WasmTable Table;
+    WasmTableType Table;
     WasmLimits Memory;
     WasmEventType Event;
   };
 };
 
 struct WasmLocalDecl {
   uint8_t Type;
   uint32_t Count;

llvm/lib/MC/WasmObjectWriter.cpp

void WasmObjectWriter::writeTableSection(ArrayRef<wasm::WasmTable> Tables) {
   if (Tables.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_TABLE);
 
   encodeULEB128(Tables.size(), W->OS);
   for (const wasm::WasmTable &Table : Tables) {
-    encodeULEB128(Table.ElemType, W->OS);
-    encodeULEB128(Table.Limits.Flags, W->OS);
-    encodeULEB128(Table.Limits.Initial, W->OS);
-    if (Table.Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
-      encodeULEB128(Table.Limits.Maximum, W->OS);
+    encodeULEB128(Table.Type.ElemType, W->OS);
+    encodeULEB128(Table.Type.Limits.Flags, W->OS);
+    encodeULEB128(Table.Type.Limits.Initial, W->OS);
+    if (Table.Type.Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
+      encodeULEB128(Table.Type.Limits.Maximum, W->OS);
   }
   endSection(Section);
 }
 
 void WasmObjectWriter::writeExportSection(ArrayRef<wasm::WasmExport> Exports) {
   if (Exports.empty())
     return;
 
if (WS.isFunction()) {
         // An import; the index was assigned above
         LLVM_DEBUG(dbgs() << "  -> global index: "
                           << WasmIndices.find(&WS)->second << "\n");
       }
     } else if (WS.isTable()) {
       if (WS.isDefined()) {
         assert(WasmIndices.count(&WS) == 0);
         wasm::WasmTable Table;
-        Table.ElemType = static_cast<uint8_t>(WS.getTableType());
         Table.Index = NumTableImports + Tables.size();
+        Table.Type.ElemType = static_cast<uint8_t>(WS.getTableType());
         // FIXME: Work on custom limits is ongoing
-        Table.Limits = {wasm::WASM_LIMITS_FLAG_NONE, 0, 0};
+        Table.Type.Limits = {wasm::WASM_LIMITS_FLAG_NONE, 0, 0};
 
         WasmIndices[&WS] = Table.Index;
         Tables.push_back(Table);
       }
       LLVM_DEBUG(dbgs() << " -> table index: " << WasmIndices.find(&WS)->second
                         << "\n");
     } else if (WS.isEvent()) {
       // C++ exception symbol (__cpp_exception)

llvm/lib/Object/WasmObjectFile.cpp

static wasm::WasmLimits readLimits(WasmObjectFile::ReadContext &Ctx) {
   wasm::WasmLimits Result;
   Result.Flags = readVaruint32(Ctx);
   Result.Initial = readVaruint64(Ctx);
   if (Result.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
     Result.Maximum = readVaruint64(Ctx);
   return Result;
 }
 
-static wasm::WasmTable readTable(WasmObjectFile::ReadContext &Ctx) {
-  wasm::WasmTable Table;
-  Table.ElemType = readUint8(Ctx);
-  Table.Limits = readLimits(Ctx);
-  // The caller needs to set Table.Index field for Table
-  return Table;
+static wasm::WasmTableType readTableType(WasmObjectFile::ReadContext &Ctx) {
+  wasm::WasmTableType TableType;
+  TableType.ElemType = readUint8(Ctx);
+  TableType.Limits = readLimits(Ctx);
+  return TableType;
 }
 
 static Error readSection(WasmSection &Section, WasmObjectFile::ReadContext &Ctx,
                          WasmSectionOrderChecker &Checker) {
   Section.Offset = Ctx.Ptr - Ctx.Start;
   Section.Type = readUint8(Ctx);
   LLVM_DEBUG(dbgs() << "readSection type=" << Section.Type << "\n");
   uint32_t Size = readVaruint32(Ctx);
case wasm::WASM_SYMBOL_TYPE_TABLE:
       if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
                             wasm::WASM_SYMBOL_BINDING_WEAK)
         return make_error<GenericBinaryError>("undefined weak table symbol",
                                               object_error::parse_failed);
       if (IsDefined) {
         Info.Name = readString(Ctx);
         unsigned TableIndex = Info.ElementIndex - NumImportedTables;
         wasm::WasmTable &Table = Tables[TableIndex];
-        TableType = Table.ElemType;
+        TableType = Table.Type.ElemType;
+        if (Table.SymbolName.empty())
+          Table.SymbolName = Info.Name;
       } else {
         return make_error<GenericBinaryError>("undefined table symbol",
                                               object_error::parse_failed);
       }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_DATA:
       Info.Name = readString(Ctx);
case wasm::WASM_EXTERNAL_GLOBAL:
       Im.Global.Mutable = readVaruint1(Ctx);
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
       Im.Memory = readLimits(Ctx);
       if (Im.Memory.Flags & wasm::WASM_LIMITS_FLAG_IS_64)
         HasMemory64 = true;
       break;
     case wasm::WASM_EXTERNAL_TABLE: {
-      Im.Table = readTable(Ctx);
-      Im.Table.Index = NumImportedTables + Tables.size();
+      Im.Table = readTableType(Ctx);
       NumImportedTables++;
       auto ElemType = Im.Table.ElemType;
       if (ElemType != wasm::WASM_TYPE_FUNCREF &&
           ElemType != wasm::WASM_TYPE_EXTERNREF)
         return make_error<GenericBinaryError>("Invalid table element type",
                                               object_error::parse_failed);
       break;
     }
return make_error<GenericBinaryError>("Function section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseTableSection(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   Tables.reserve(Count);
   while (Count--) {
-    wasm::WasmTable T = readTable(Ctx);
+    wasm::WasmTable T;
+    T.Type = readTableType(Ctx);
     T.Index = NumImportedTables + Tables.size();
     Tables.push_back(T);
-    auto ElemType = Tables.back().ElemType;
+    auto ElemType = Tables.back().Type.ElemType;
     if (ElemType != wasm::WASM_TYPE_FUNCREF &&
         ElemType != wasm::WASM_TYPE_EXTERNREF) {
       return make_error<GenericBinaryError>("Invalid table element type",
                                             object_error::parse_failed);
     }
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("Table section ended prematurely",

llvm/tools/obj2yaml/wasm2yaml.cpp

public:
   ErrorOr<WasmYAML::Object *> dump();
 
   std::unique_ptr<WasmYAML::CustomSection>
   dumpCustomSection(const WasmSection &WasmSec);
 };
 
 } // namespace
 
-static WasmYAML::Table makeTable(const wasm::WasmTable &Table) {
-  WasmYAML::Table T;
-  T.ElemType = Table.ElemType;
-  T.TableLimits.Flags = Table.Limits.Flags;
-  T.TableLimits.Initial = Table.Limits.Initial;
-  T.TableLimits.Maximum = Table.Limits.Maximum;
-  T.Index = Table.Index;
-  return T;
-}
-
 static WasmYAML::Limits makeLimits(const wasm::WasmLimits &Limits) {
   WasmYAML::Limits L;
   L.Flags = Limits.Flags;
   L.Initial = Limits.Initial;
   L.Maximum = Limits.Maximum;
   return L;
 }
 
+static WasmYAML::Table makeTable(uint32_t Index,
+                                 const wasm::WasmTableType &Type) {
+  WasmYAML::Table T;
+  T.Index = Index;
+  T.ElemType = Type.ElemType;
+  T.TableLimits = makeLimits(Type.Limits);
+  return T;
+}
+
 std::unique_ptr<WasmYAML::CustomSection>
 WasmDumper::dumpCustomSection(const WasmSection &WasmSec) {
   std::unique_ptr<WasmYAML::CustomSection> CustomSec;
   if (WasmSec.Name == "dylink") {
     std::unique_ptr<WasmYAML::DylinkSection> DylinkSec =
         std::make_unique<WasmYAML::DylinkSection>();
     const wasm::WasmDylinkInfo& Info = Obj.dylinkInfo();
     DylinkSec->MemorySize = Info.MemorySize;
case wasm::WASM_SEC_IMPORT: {
           Im.GlobalImport.Type = Import.Global.Type;
           Im.GlobalImport.Mutable = Import.Global.Mutable;
           break;
         case wasm::WASM_EXTERNAL_EVENT:
           Im.EventImport.Attribute = Import.Event.Attribute;
           Im.EventImport.SigIndex = Import.Event.SigIndex;
           break;
         case wasm::WASM_EXTERNAL_TABLE:
-          Im.TableImport = makeTable(Import.Table);
+          // FIXME: Currently we always output an index of 0 for any imported
+          // table.
+          Im.TableImport = makeTable(0, Import.Table);
           break;
         case wasm::WASM_EXTERNAL_MEMORY:
           Im.Memory = makeLimits(Import.Memory);
           break;
         }
         ImportSec->Imports.push_back(Im);
       }
       S = std::move(ImportSec);
       break;
     }
     case wasm::WASM_SEC_FUNCTION: {
       auto FuncSec = std::make_unique<WasmYAML::FunctionSection>();
       for (const auto &Func : Obj.functionTypes()) {
         FuncSec->FunctionTypes.push_back(Func);
       }
       S = std::move(FuncSec);
       break;
     }
     case wasm::WASM_SEC_TABLE: {
       auto TableSec = std::make_unique<WasmYAML::TableSection>();
       for (const wasm::WasmTable &Table : Obj.tables()) {
-        TableSec->Tables.push_back(makeTable(Table));
+        TableSec->Tables.push_back(makeTable(Table.Index, Table.Type));
       }
       S = std::move(TableSec);
       break;
     }
     case wasm::WASM_SEC_MEMORY: {
       auto MemorySec = std::make_unique<WasmYAML::MemorySection>();
       for (const wasm::WasmLimits &Memory : Obj.memories()) {
         MemorySec->Memories.push_back(makeLimits(Memory));