[WebAssembly] Rename WasmLimits::Initial to ::Minimum. NFC.

[wingo]

Summary

This patch renames the "Initial" member of WasmLimits to the name used
in the spec, "Minimum".

In the core WebAssembly specification, the Limits data type has one
required "min" member and one optional "max" member, indicating the
minimum required size of the corresponding table or memory, and the
maximum size, if any.

Although the WebAssembly spec does instantiate locally-defined tables
and memories with the initial size being equal to the minimum size, it
can't impose such a requirement for imports. It doesn't make sense to
require an initial size for a memory import, for example. The compiler
can only sensibly express the minimum and maximum sizes.

See
https://github.com/WebAssembly/js-types/blob/master/proposals/js-types/Overview.md#naming-of-size-limits
for a related discussion that agrees that the right name of "initial" is
"minimum" when querying the type of a table or memory from JavaScript.
(Of course it still makes sense for JS to speak in terms of an initial
size when it explicitly instantiates memories and tables.)

[wingo]

Commit log says it all. Sam feel free to pass this one off to someone else, or to tell me this is a terrible idea!

[wingo]

Add missing rename from Initial to Minimum

[wingo]

Fix missing test adaptations

lld/test/wasm/alias.s

 # CHECK-NEXT:     Signatures:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         ParamTypes:
 # CHECK-NEXT:         ReturnTypes:     []
 # CHECK-NEXT:   - Type:            FUNCTION
 # CHECK-NEXT:     FunctionTypes:   [ 0 ]
 # CHECK-NEXT:   - Type:            MEMORY
 # CHECK-NEXT:     Memories:
-# CHECK-NEXT:       - Initial:         0x2
+# CHECK-NEXT:       - Minimum:         0x2
 # CHECK-NEXT:   - Type:            GLOBAL
 # CHECK-NEXT:     Globals:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Type:            I32
 # CHECK-NEXT:         Mutable:         true
 # CHECK-NEXT:         InitExpr:
 # CHECK-NEXT:           Opcode:          I32_CONST
 # CHECK-NEXT:           Value:           66560

lld/test/wasm/bsymbolic.s

 // RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t.o
 // RUN: wasm-ld --no-entry -Bsymbolic %t.o -o %t.wasm 2>&1 | FileCheck -check-prefix=WARNING %s
 // WARNING: warning: -Bsymbolic is only meaningful when combined with -shared
 
 // RUN: wasm-ld --experimental-pic -shared %t.o -o %t0.so
 // RUN: obj2yaml %t0.so | FileCheck -check-prefix=NOOPTION %s
 
 // RUN: wasm-ld --experimental-pic -shared -Bsymbolic %t.o -o %t1.so
 // RUN: obj2yaml %t1.so | FileCheck -check-prefix=SYMBOLIC %s
 
 // NOOPTION:       - Type:            IMPORT
 // NOOPTION-NEXT:    Imports:
 // NOOPTION-NEXT:      - Module:          env
 // NOOPTION-NEXT:        Field:           memory
 // NOOPTION-NEXT:        Kind:            MEMORY
 // NOOPTION-NEXT:        Memory:
-// NOOPTION-NEXT:          Initial:         0x1
+// NOOPTION-NEXT:          Minimum:         0x1
 // NOOPTION-NEXT:      - Module:          env
 // NOOPTION-NEXT:        Field:           __memory_base
 // NOOPTION-NEXT:        Kind:            GLOBAL
 // NOOPTION-NEXT:        GlobalType:      I32
 // NOOPTION-NEXT:        GlobalMutable:   false
 // NOOPTION-NEXT:      - Module:          env
 // NOOPTION-NEXT:        Field:           __table_base
 // NOOPTION-NEXT:        Kind:            GLOBAL

 // SYMBOLIC-NOT:   - Module:          GOT.func
 
 // SYMBOLIC:       - Type:            IMPORT
 // SYMBOLIC-NEXT:    Imports:
 // SYMBOLIC-NEXT:      - Module:          env
 // SYMBOLIC-NEXT:        Field:           memory
 // SYMBOLIC-NEXT:        Kind:            MEMORY
 // SYMBOLIC-NEXT:        Memory:
-// SYMBOLIC-NEXT:          Initial:         0x1
+// SYMBOLIC-NEXT:          Minimum:         0x1
 // SYMBOLIC-NEXT:      - Module:          env
 // SYMBOLIC-NEXT:        Field:           __memory_base
 // SYMBOLIC-NEXT:        Kind:            GLOBAL
 // SYMBOLIC-NEXT:        GlobalType:      I32
 // SYMBOLIC-NEXT:        GlobalMutable:   false
 // SYMBOLIC-NEXT:      - Module:          env
 // SYMBOLIC-NEXT:        Field:           __table_base
 // SYMBOLIC-NEXT:        Kind:            GLOBAL
 // SYMBOLIC-NEXT:        GlobalType:      I32
 // SYMBOLIC-NEXT:        GlobalMutable:   false
 // SYMBOLIC-NEXT:      - Module:          env
 // SYMBOLIC-NEXT:        Field:           __indirect_function_table
 // SYMBOLIC-NEXT:        Kind:            TABLE
 // SYMBOLIC-NEXT:        Table:
 // SYMBOLIC-NEXT:          Index:           0
 // SYMBOLIC-NEXT:          ElemType:        FUNCREF
 // SYMBOLIC-NEXT:          Limits:
-// SYMBOLIC-NEXT:            Initial:         0x1
+// SYMBOLIC-NEXT:            Minimum:         0x1
 // SYMBOLIC-NEXT:  - Type:            FUNCTION
 
 // SYMBOLIC:       - Type:            GLOBAL
 // SYMBOLIC-NEXT:    Globals:
 // SYMBOLIC-NEXT:      - Index:           2
 // SYMBOLIC-NEXT:        Type:            I32
 // SYMBOLIC-NEXT:        Mutable:         true
 // SYMBOLIC-NEXT:        InitExpr:

lld/test/wasm/call-indirect.ll

 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 3, 1, 3, 4 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ElemType:        FUNCREF
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
-; CHECK-NEXT:           Initial:         0x3
+; CHECK-NEXT:           Minimum:         0x3
 ; CHECK-NEXT:           Maximum:         0x3
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
-; CHECK-NEXT:       - Initial:         0x2
+; CHECK-NEXT:       - Minimum:         0x2
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66576

lld/test/wasm/data-layout.s

 local_struct_internal_ptr:
         .int32  local_struct+4
         .size   local_struct_internal_ptr, 4
         .size   hello_str, 4
 
 # CHECK:        - Type:            MEMORY
 # CHECK-NEXT:     Memories:
 # CHK64-NEXT:       - Flags:           [ IS_64 ]
-# CHECK-NEXT:         Initial:         0x2
+# CHECK-NEXT:         Minimum:         0x2
 # CHECK-NEXT:   - Type:            GLOBAL
 # CHECK-NEXT:     Globals:
 # CHECK-NEXT:       - Index:           0
 # CHK32-NEXT:         Type:            I32
 # CHK64-NEXT:         Type:            I64
 # CHECK-NEXT:         Mutable:         true
 # CHECK-NEXT:         InitExpr:
 # CHK32-NEXT:           Opcode:          I32_CONST

 # RUN: wasm-ld -no-gc-sections --allow-undefined --no-entry \
 # RUN:     --initial-memory=131072 --max-memory=131072 -o %t_max.wasm %t32.o \
 # RUN:     %t.hello32.o
 # RUN: obj2yaml %t_max.wasm | FileCheck %s -check-prefix=CHECK-MAX
 
 # CHECK-MAX:        - Type:            MEMORY
 # CHECK-MAX-NEXT:     Memories:
 # CHECK-MAX-NEXT:       - Flags:           [ HAS_MAX ]
-# CHECK-MAX-NEXT:         Initial:         0x2
+# CHECK-MAX-NEXT:         Minimum:         0x2
 # CHECK-MAX-NEXT:         Maximum:         0x2
 
 # RUN: wasm-ld -no-gc-sections --allow-undefined --no-entry --shared-memory \
 # RUN:     --features=atomics,bulk-memory --initial-memory=131072 \
 # RUN:     --max-memory=131072 -o %t_max.wasm %t32.o %t.hello32.o
 # RUN: obj2yaml %t_max.wasm | FileCheck %s -check-prefix=CHECK-SHARED
 
 # CHECK-SHARED:        - Type:            MEMORY
 # CHECK-SHARED-NEXT:     Memories:
 # CHECK-SHARED-NEXT:       - Flags:           [ HAS_MAX, IS_SHARED ]
-# CHECK-SHARED-NEXT:         Initial:         0x2
+# CHECK-SHARED-NEXT:         Minimum:         0x2
 # CHECK-SHARED-NEXT:         Maximum:         0x2
 
 # XUN: wasm-ld --relocatable -o %t_reloc.wasm %t32.o %t.hello32.o
 # XUN: obj2yaml %t_reloc.wasm | FileCheck %s -check-prefix=RELOC
 
 # RELOC:       - Type:            DATA
 # RELOC-NEXT:     Relocations:
 # RELOC-NEXT:       - Type:            R_WASM_MEMORY_ADDR_I32

lld/test/wasm/export-table-explicit.test

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/start.s -o %t.start.o
 # RUN: wasm-ld --export-table -o %t.wasm %t.start.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Verify the interaction between --export-table and declared tables
 
 .globl __indirect_function_table
 .tabletype __indirect_function_table,externref
 
 # CHECK:        - Type:            TABLE
 # CHECK-NEXT:     Tables:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         ElemType:        FUNCREF
 # CHECK-NEXT:         Limits:
 # CHECK-NEXT:           Flags:           [ HAS_MAX ]
-# CHECK-NEXT:           Initial:         0x1
+# CHECK-NEXT:           Minimum:         0x1
 # CHECK-NEXT:           Maximum:         0x1
 # CHECK-NEXT:   - Type:
 
 # CHECK:        - Type:            EXPORT
 # CHECK-NEXT:     Exports:
 # CHECK-NEXT:       - Name:            memory
 # CHECK-NEXT:         Kind:            MEMORY
 # CHECK-NEXT:         Index:           0
 # CHECK-NEXT:       - Name:            _start
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Index:           0
 # CHECK-NEXT:       - Name:            __indirect_function_table
 # CHECK-NEXT:         Kind:            TABLE
 # CHECK-NEXT:         Index:           0
 # CHECK-NEXT:   - Type:

lld/test/wasm/export-table.test

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/start.s -o %t.start.o
 # RUN: wasm-ld --export-table -o %t.wasm %t.start.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Verify the --export-table flag creates a table export
 
 # CHECK:        - Type:            TABLE
 # CHECK-NEXT:     Tables:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         ElemType:        FUNCREF
 # CHECK-NEXT:         Limits:
 # CHECK-NEXT:           Flags:           [ HAS_MAX ]
-# CHECK-NEXT:           Initial:         0x1
+# CHECK-NEXT:           Minimum:         0x1
 # CHECK-NEXT:           Maximum:         0x1
 # CHECK-NEXT:   - Type:
 # CHECK:        - Type:            EXPORT
 # CHECK-NEXT:     Exports:
 # CHECK:            - Name:            __indirect_function_table
 # CHECK-NEXT:         Kind:            TABLE
 # CHECK-NEXT:         Index:           0

lld/test/wasm/growable-table.test

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/start.s -o %t.start.o
 # RUN: wasm-ld --export-table --growable-table -o %t.wasm %t.start.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Verify the --growable-table flag creates a growable table
 
 # CHECK:        - Type:            TABLE
 # CHECK-NEXT:     Tables:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         ElemType:        FUNCREF
 # CHECK-NEXT:         Limits:
-# CHECK-NEXT:           Initial:         0x1
+# CHECK-NEXT:           Minimum:       0x1
 # CHECK-NEXT:   - Type:
 # CHECK:        - Type:            EXPORT
 # CHECK-NEXT:     Exports:
 # CHECK:            - Name:            __indirect_function_table
 # CHECK-NEXT:         Kind:            TABLE
 # CHECK-NEXT:         Index:           0

lld/test/wasm/import-memory.test

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/start.s -o %t.start.o
 # RUN: wasm-ld --import-memory -o %t.wasm %t.start.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Verify the --import-memory flag creates a memory import
 
 # CHECK:       - Type:            IMPORT
 # CHECK-NEXT:    Imports:
 # CHECK-NEXT:      - Module:          env
 # CHECK-NEXT:        Field:           memory
 # CHECK-NEXT:        Kind:            MEMORY
 # CHECK-NEXT:        Memory:
-# CHECK-NEXT:          Initial:         0x2
+# CHECK-NEXT:          Minimum:         0x2
 # CHECK-NEXT:  - Type:
 
 
 
 # RUN: wasm-ld --import-memory --initial-memory=262144 \
 # RUN:     --max-memory=327680 -o %t.max.wasm %t.start.o
 # RUN: obj2yaml %t.max.wasm | FileCheck -check-prefix=CHECK-MAX %s
 
 # Verify the --initial-memory and --max-memory arguments work with imports
 
 # CHECK-MAX:       - Type:            IMPORT
 # CHECK-MAX-NEXT:    Imports:
 # CHECK-MAX-NEXT:      - Module:          env
 # CHECK-MAX-NEXT:        Field:           memory
 # CHECK-MAX-NEXT:        Kind:            MEMORY
 # CHECK-MAX-NEXT:        Memory:
 # CHECK-MAX-NEXT:          Flags:           [ HAS_MAX ]
-# CHECK-MAX-NEXT:          Initial:         0x4
+# CHECK-MAX-NEXT:          Minimum:         0x4
 # CHECK-MAX-NEXT:          Maximum:         0x5
 # CHECK-MAX-NEXT:  - Type:
 
 # RUN: wasm-ld --import-memory --shared-memory --features=atomics,bulk-memory \
 # RUN:     --initial-memory=262144 --max-memory=327680 -o %t.max.wasm %t.start.o
 # RUN: obj2yaml %t.max.wasm | FileCheck -check-prefix=CHECK-SHARED %s
 
 # Verify the --shared-memory flag works with imports
 
 # CHECK-SHARED:       - Type:            IMPORT
 # CHECK-SHARED-NEXT:    Imports:
 # CHECK-SHARED-NEXT:      - Module:          env
 # CHECK-SHARED-NEXT:        Field:           memory
 # CHECK-SHARED-NEXT:        Kind:            MEMORY
 # CHECK-SHARED-NEXT:        Memory:
 # CHECK-SHARED-NEXT:          Flags:           [ HAS_MAX, IS_SHARED ]
-# CHECK-SHARED-NEXT:          Initial:         0x4
+# CHECK-SHARED-NEXT:          Minimum:         0x4
 # CHECK-SHARED-NEXT:          Maximum:         0x5
 # CHECK-SHARED-NEXT:  - Type:

lld/test/wasm/import-table.test

 # CHECK-NEXT:    Imports:
 # CHECK-NEXT:      - Module:          env
 # CHECK-NEXT:        Field:           __indirect_function_table
 # CHECK-NEXT:        Kind:            TABLE
 # CHECK-NEXT:        Table:
 # CHECK-NEXT:          Index:           0
 # CHECK-NEXT:          ElemType:        FUNCREF
 # CHECK-NEXT:          Limits:
-# CHECK-NEXT:            Initial:         0x1
+# CHECK-NEXT:            Minimum:         0x1
 

lld/test/wasm/large-memory.test

 RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/start.s -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 %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:         0x2
+CHECK-NEXT:       Minimum:         0x2
 CHECK-2G-NEXT:    Maximum:         0x8000
 CHECK-4G-NEXT:    Maximum:         0x10000
 
 ; 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/test/wasm/local-symbols.ll

 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:         ReturnTypes:     []
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 1 ]
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
-; CHECK-NEXT:       - Initial:         0x2
+; CHECK-NEXT:       - Minimum:         0x2
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66576

lld/test/wasm/locals-duplicate.test

 ; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 ; CHECK-NEXT:                        0, 0 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ElemType:        FUNCREF
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
-; CHECK-NEXT:           Initial:         0x7
+; CHECK-NEXT:           Minimum:         0x7
 ; CHECK-NEXT:           Maximum:         0x7
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
-; CHECK-NEXT:       - Initial:         0x2
+; CHECK-NEXT:       - Minimum:         0x2
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66592

 ; RELOC-NEXT:    Imports:
 ; RELOC-NEXT:      - Module:          env
 ; RELOC-NEXT:        Field:           __indirect_function_table
 ; RELOC-NEXT:        Kind:            TABLE
 ; RELOC-NEXT:        Table:
 ; RELOC-NEXT:          Index:           0
 ; RELOC-NEXT:          ElemType:        FUNCREF
 ; RELOC-NEXT:          Limits:
-; RELOC-NEXT:            Initial:         0x7
+; RELOC-NEXT:            Minimum:         0x7
 ; RELOC-NEXT:   - Type:            FUNCTION
 ; RELOC-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 ; RELOC-NEXT:                        0, 0 ]
 ; RELOC-NEXT:   - Type:            MEMORY
 ; RELOC-NEXT:     Memories:
-; RELOC-NEXT:       - Initial:         0x1
+; RELOC-NEXT:       - Minimum:         0x1
 ; RELOC-NEXT:   - Type:            ELEM
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           1
 ; RELOC-NEXT:         Functions:       [ 0, 1, 2, 9, 10, 11 ]
 ; RELOC-NEXT:   - Type:            CODE
 ; RELOC-NEXT:     Relocations:

lld/test/wasm/multi-table.s

 # CHECK-NEXT:     Imports:
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           table_a
 # CHECK-NEXT:         Kind:            TABLE
 # CHECK-NEXT:         Table:
 # CHECK-NEXT:           Index:           0
 # CHECK-NEXT:           ElemType:        FUNCREF
 # CHECK-NEXT:           Limits:
-# CHECK-NEXT:             Initial:         0x0
+# CHECK-NEXT:             Minimum:         0x0
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           foo
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         SigIndex:        2
 # CHECK-NEXT:   - Type:            FUNCTION
 # CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0 ]
 # CHECK-NEXT:   - Type:            TABLE
 # CHECK-NEXT:     Tables:
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         ElemType:        FUNCREF
 # CHECK-NEXT:         Limits:
-# CHECK-NEXT:           Initial:         0x0
+# CHECK-NEXT:           Minimum:         0x0
 # CHECK-NEXT:       - Index:           2
 # CHECK-NEXT:         ElemType:        EXTERNREF
 # CHECK-NEXT:         Limits:
-# CHECK-NEXT:           Initial:         0x0
+# CHECK-NEXT:           Minimum:         0x0
 # CHECK-NEXT:       - Index:           3
 # CHECK-NEXT:         ElemType:        FUNCREF
 # CHECK-NEXT:         Limits:
 # CHECK-NEXT:           Flags:           [ HAS_MAX ]
-# CHECK-NEXT:           Initial:         0x3
+# CHECK-NEXT:           Minimum:         0x3
 # CHECK-NEXT:           Maximum:         0x3
 # CHECK-NEXT:   - Type:            MEMORY
 # CHECK-NEXT:     Memories:
-# CHECK-NEXT:       - Initial:         0x2
+# CHECK-NEXT:       - Minimum:         0x2
 # CHECK-NEXT:   - Type:            GLOBAL
 # CHECK-NEXT:     Globals:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Type:            I32
 # CHECK-NEXT:         Mutable:         true
 # CHECK-NEXT:         InitExpr:
 # CHECK-NEXT:           Opcode:          I32_CONST
 # CHECK-NEXT:           Value:           66576

lld/test/wasm/pie.ll

 ; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __indirect_function_table
 ; CHECK-NEXT:         Kind:            TABLE
 ; CHECK-NEXT:         Table:
 ; CHECK-NEXT:           Index:           0
 ; CHECK-NEXT:           ElemType:        FUNCREF
 ; CHECK-NEXT:           Limits:
-; CHECK-NEXT:             Initial:         0x1
+; CHECK-NEXT:             Minimum:         0x1
 
 ; CHECK:        - Type:            START
 ; CHECK-NEXT:     StartFunction:   2
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0

lld/test/wasm/relocatable.ll

 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __indirect_function_table
 ; CHECK-NEXT:         Kind:            TABLE
 ; CHECK-NEXT:         Table:
 ; CHECK-NEXT:           Index:           0
 ; CHECK-NEXT:           ElemType:        FUNCREF
 ; CHECK-NEXT:           Limits:
-; CHECK-NEXT:             Initial:         0x4
+; CHECK-NEXT:             Minimum:         0x4
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           puts
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           foo_import
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           bar_import
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 2, 1, 1, 2 ]
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
-; CHECK-NEXT:      - Initial:         0x1
+; CHECK-NEXT:      - Minimum:         0x1
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 4, 1, 2 ]
 ; SHARED-NEXT:  - Type:            DATACOUNT
 ; SHARED-NEXT:    Count:           6

lld/test/wasm/responsefile.test

 RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/ret32.s -o %t.o
 
 RUN: echo "%/t.o -o %/t.wasm -e ret32" > %t.rsp
 RUN: wasm-ld @%t.rsp --initial-memory=655360
 RUN: llvm-readobj --sections %t.wasm | FileCheck %s
-CHECK: InitialPages: 10
+CHECK: MinPages: 10
 
 RUN: not wasm-ld --rsp-quoting=foobar @%t.rsp 2>&1 | \
 RUN:     FileCheck --check-prefix=INVRSP %s
 INVRSP: invalid response file quoting: foobar
 
 RUN: echo "blah\foo" > %t.rsp
 RUN: not wasm-ld -o a.out --rsp-quoting=windows @%t.rsp 2>&1 | \
 RUN:     FileCheck --check-prefix=WINRSP %s
 WINRSP: error: cannot open blah\foo:
 
 RUN: echo "blah\foo" > %t.rsp
 RUN: not wasm-ld -o a.out --rsp-quoting=posix @%t.rsp 2>&1 | \
 RUN:     FileCheck --check-prefix=POSRSP %s
 POSRSP: error: cannot open blahfoo:

lld/test/wasm/shared-memory-no-atomics.yaml

 # RUN: yaml2obj %s -o %t1.o
 
 # RUN: wasm-ld --no-entry %t1.o -o - | obj2yaml | FileCheck %s --check-prefix NO-SHARED
 
 # RUN: not wasm-ld --no-entry --shared-memory --max-memory=131072 %t1.o -o - 2>&1 | FileCheck %s --check-prefix SHARED
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            IMPORT
     Imports:
       - Module:          env
         Field:           __linear_memory
         Kind:            MEMORY
         Memory:
-          Initial:         0x00000001
+          Minimum:         0x00000001
       - Module:          env
         Field:           __indirect_function_table
         Kind:            TABLE
         Table:
           Index:           0
           ElemType:        FUNCREF
           Limits:
-            Initial:         0x00000000
+            Minimum:         0x00000000
   - Type:            DATA
     Segments:
       - SectionOffset:   6
         InitFlags:       0
         Offset:
           Opcode:          I32_CONST
           Value:           0
         Content:         68656C6C6F0A00
- Type:            CUSTOM
     Name:            target_features
     Features:
       - Prefix:        DISALLOWED
         Name:          "shared-mem"
 ...
 
 # NO-SHARED:      - Type:            MEMORY
 # NO-SHARED-NEXT:   Memories:
-# NO-SHARED-NEXT:     - Initial:         0x2
+# NO-SHARED-NEXT:     - Minimum:         0x2
 # NO-SHARED-NOT:        Maximum:
 
 # SHARED: --shared-memory is disallowed by {{.*}}shared-memory-no-atomics.yaml.tmp1.o because it was not compiled with 'atomics' or 'bulk-memory' features.

lld/test/wasm/shared-memory.yaml

FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            IMPORT
     Imports:
       - Module:          env
         Field:           __linear_memory
         Kind:            MEMORY
         Memory:
-          Initial:         0x00000001
+          Minimum:         0x00000001
       - Module:          env
         Field:           __indirect_function_table
         Kind:            TABLE
         Table:
           Index:           0
           ElemType:        FUNCREF
           Limits:
-            Initial:         0x00000000
+            Minimum:         0x00000000
   - Type:            DATA
     Segments:
       - SectionOffset:   6
         InitFlags:       0
         Offset:
           Opcode:          I32_CONST
           Value:           0
         Content:         68656C6C6F0A00

 # SHARED-UNALIGNED: maximum memory must be 65536-byte aligned{{$}}
 
 # SHARED-NO-ATOMICS: 'atomics' feature must be used in order to use shared memory
 
 # SHARED-NO-BULK-MEM: 'bulk-memory' feature must be used in order to use shared memory
 
 # ATOMICS-RELOCATABLE:        - Type:            MEMORY
 # ATOMICS-RELOCATABLE-NEXT:     Memories:
-# ATOMICS-RELOCATABLE-NEXT:         Initial:         0x1
+# ATOMICS-RELOCATABLE-NEXT:         Minimum:         0x1
 # ATOMICS-RELOCATABLE-NEXT:   - Type:
 
 # SHARED:        - Type:            MEMORY
 # SHARED-NEXT:     Memories:
 # SHARED-NEXT:       - Flags:           [ HAS_MAX, IS_SHARED ]
-# SHARED-NEXT:         Initial:         0x2
+# SHARED-NEXT:         Minimum:         0x2
 # SHARED-NEXT:         Maximum:         0x2

lld/test/wasm/shared.ll

 ; check for import of __table_base and __memory_base globals
 
 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Memory:
-; CHECK-NEXT:           Initial:       0x1
+; CHECK-NEXT:           Minimum:       0x1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __indirect_function_table
 ; CHECK-NEXT:         Kind:            TABLE
 ; CHECK-NEXT:         Table:
 ; CHECK-NEXT:           Index:           0
 ; CHECK-NEXT:           ElemType:        FUNCREF
 ; CHECK-NEXT:           Limits:
-; CHECK-NEXT:             Initial:         0x2
+; CHECK-NEXT:             Minimum:         0x2
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __stack_pointer
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   true
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __memory_base
 ; CHECK-NEXT:         Kind:            GLOBAL

lld/test/wasm/stack-pointer.ll

 ; CHECK-NEXT:         Field:           __stack_pointer
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   true
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0 ]
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
-; CHECK-NEXT:       - Initial:         0x0
+; CHECK-NEXT:       - Minimum:         0x0
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x4
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:

lld/test/wasm/undefined-weak-call.s

 # CHECK-NEXT:   - Type:            FUNCTION
 # CHECK-NEXT:     FunctionTypes:   [ 0, 0, 1, 2 ]
 # CHECK-NEXT:   - Type:            TABLE
 # CHECK-NEXT:     Tables:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         ElemType:        FUNCREF
 # CHECK-NEXT:         Limits:
 # CHECK-NEXT:           Flags:           [ HAS_MAX ]
-# CHECK-NEXT:           Initial:         0x1
+# CHECK-NEXT:           Minimum:         0x1
 # CHECK-NEXT:           Maximum:         0x1
 # CHECK-NEXT:   - Type:            MEMORY
 # CHECK-NEXT:     Memories:
-# CHECK-NEXT:       - Initial:         0x2
+# CHECK-NEXT:       - Minimum:         0x2
 # CHECK-NEXT:   - Type:            GLOBAL
 # CHECK-NEXT:     Globals:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Type:            I32
 # CHECK-NEXT:         Mutable:         true
 # CHECK-NEXT:         InitExpr:
 # CHECK-NEXT:           Opcode:          I32_CONST
 # CHECK-NEXT:           Value:           66560

lld/test/wasm/weak-alias-overide.ll

 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 0, 0, 0, 0 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ElemType:        FUNCREF
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
-; CHECK-NEXT:           Initial:         0x3
+; CHECK-NEXT:           Minimum:         0x3
 ; CHECK-NEXT:           Maximum:         0x3
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
-; CHECK-NEXT:       - Initial:         0x2
+; CHECK-NEXT:       - Minimum:         0x2
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66560

lld/test/wasm/weak-alias.ll

 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 1, 1, 1, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ElemType:        FUNCREF
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
-; CHECK-NEXT:           Initial:         0x2
+; CHECK-NEXT:           Minimum:         0x2
 ; CHECK-NEXT:           Maximum:         0x2
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
-; CHECK-NEXT:       - Initial:         0x2
+; CHECK-NEXT:       - Minimum:         0x2
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66560

 ; RELOC-NEXT:     Imports:
 ; RELOC-NEXT:       - Module:          env
 ; RELOC-NEXT:         Field:           __indirect_function_table
 ; RELOC-NEXT:         Kind:            TABLE
 ; RELOC-NEXT:         Table:
 ; RELOC-NEXT:           Index:           0
 ; RELOC-NEXT:           ElemType:        FUNCREF
 ; RELOC-NEXT:           Limits:
-; RELOC-NEXT:             Initial:         0x2
+; RELOC-NEXT:             Minimum:         0x2
 ; RELOC-NEXT:       - Module:          env
 ; RELOC-NEXT:         Field:           __stack_pointer
 ; RELOC-NEXT:         Kind:            GLOBAL
 ; RELOC-NEXT:         GlobalType:      I32
 ; RELOC-NEXT:         GlobalMutable:   true
 ; RELOC-NEXT:   - Type:            FUNCTION
 ; RELOC-NEXT:     FunctionTypes:   [ 0, 1, 1, 1, 1, 1 ]
 ; RELOC-NEXT:   - Type:            MEMORY
 ; RELOC-NEXT:     Memories:
-; RELOC-NEXT:       - Initial:         0x0
+; RELOC-NEXT:       - Minimum:         0x0
 ; RELOC-NEXT:   - Type:            ELEM
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           1
 ; RELOC-NEXT:         Functions:       [ 1 ]
 ; RELOC-NEXT:   - Type:            CODE
 ; RELOC-NEXT:     Relocations:

lld/test/wasm/weak-symbols.s

 # CHECK-NEXT:   - Type:            FUNCTION
 # CHECK-NEXT:     FunctionTypes:   [ 0, 1, 1, 1 ]
 # CHECK-NEXT:   - Type:            TABLE
 # CHECK-NEXT:     Tables:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         ElemType:        FUNCREF
 # CHECK-NEXT:         Limits:
 # CHECK-NEXT:           Flags:           [ HAS_MAX ]
-# CHECK-NEXT:           Initial:         0x2
+# CHECK-NEXT:           Minimum:         0x2
 # CHECK-NEXT:           Maximum:         0x2
 # CHECK-NEXT:   - Type:            MEMORY
 # CHECK-NEXT:     Memories:
-# CHECK-NEXT:       - Initial:         0x2
+# CHECK-NEXT:       - Minimum:         0x2
 # CHECK-NEXT:   - Type:            GLOBAL
 # CHECK-NEXT:     Globals:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Type:            I32
 # CHECK-NEXT:         Mutable:         true
 # CHECK-NEXT:         InitExpr:
 # CHECK-NEXT:           Opcode:          I32_CONST
 # CHECK-NEXT:           Value:           66576

lld/test/wasm/weak-undefined.s

 # CHECK-NEXT:   - Type:            FUNCTION
 # CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 1 ]
 # CHECK-NEXT:   - Type:            TABLE
 # CHECK-NEXT:     Tables:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         ElemType:        FUNCREF
 # CHECK-NEXT:         Limits:
 # CHECK-NEXT:           Flags:           [ HAS_MAX ]
-# CHECK-NEXT:           Initial:         0x1
+# CHECK-NEXT:           Minimum:         0x1
 # CHECK-NEXT:           Maximum:         0x1
 # CHECK-NEXT:   - Type:            MEMORY
 # CHECK-NEXT:     Memories:
-# CHECK-NEXT:       - Initial:         0x2
+# CHECK-NEXT:       - Minimum:         0x2
 # CHECK-NEXT:   - Type:            GLOBAL
 # CHECK-NEXT:     Globals:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Type:            I32
 # CHECK-NEXT:         Mutable:         true
 # CHECK-NEXT:         InitExpr:
 # CHECK-NEXT:           Opcode:          I32_CONST
 # CHECK-NEXT:           Value:           66560

lld/wasm/SyntheticSections.cpp

void ImportSection::writeBody() {
   writeUleb128(os, getNumImports(), "import count");
 
   if (config->importMemory) {
     WasmImport import;
     import.Module = defaultModule;
     import.Field = "memory";
     import.Kind = WASM_EXTERNAL_MEMORY;
     import.Memory.Flags = 0;
-    import.Memory.Initial = out.memorySec->numMemoryPages;
+    import.Memory.Minimum = out.memorySec->numMemoryPages;
     if (out.memorySec->maxMemoryPages != 0 || config->sharedMemory) {
       import.Memory.Flags |= WASM_LIMITS_FLAG_HAS_MAX;
       import.Memory.Maximum = out.memorySec->maxMemoryPages;
     }
     if (config->sharedMemory)
       import.Memory.Flags |= WASM_LIMITS_FLAG_IS_SHARED;
     if (config->is64.getValueOr(false))
       import.Memory.Flags |= WASM_LIMITS_FLAG_IS_64;

lld/wasm/Writer.cpp

if (shouldImport(WasmSym::indirectFunctionTable) &&
     // added to the tables section later in assignIndexes.
     out.importSec->addImport(WasmSym::indirectFunctionTable);
   }
 
   uint32_t tableSize = config->tableBase + out.elemSec->numEntries();
   WasmLimits limits = {0, tableSize, 0};
   if (WasmSym::indirectFunctionTable->isDefined() && !config->growableTable) {
     limits.Flags |= WASM_LIMITS_FLAG_HAS_MAX;
-    limits.Maximum = limits.Initial;
+    limits.Maximum = limits.Minimum;
   }
   WasmSym::indirectFunctionTable->setLimits(limits);
 }
 
 static void scanRelocations() {
   for (ObjFile *file : symtab->objectFiles) {
     LLVM_DEBUG(dbgs() << "scanRelocations: " << file->getName() << "\n");
     for (InputChunk *chunk : file->functions)

lld/wasm/WriterUtils.cpp

std::string toString(const WasmEventType &type) {
   if (type.Attribute == WASM_EVENT_ATTRIBUTE_EXCEPTION)
     return "exception";
   return "unknown";
 }
 
 static std::string toString(const llvm::wasm::WasmLimits &limits) {
   std::string ret;
   ret += "flags=0x" + std::to_string(limits.Flags);
-  ret += "; initial=" + std::to_string(limits.Initial);
+  ret += "; min=" + std::to_string(limits.Minimum);
   if (limits.Flags & WASM_LIMITS_FLAG_HAS_MAX)
     ret += "; max=" + std::to_string(limits.Maximum);
   return ret;
 }
 
 std::string toString(const WasmTableType &type) {
   SmallString<128> ret("");
   return "type=" + toString(static_cast<ValType>(type.ElemType)) +
void writeInitExpr(raw_ostream &os, const WasmInitExpr &initExpr) {
   default:
     fatal("unknown opcode in init expr: " + Twine(initExpr.Opcode));
   }
   writeU8(os, WASM_OPCODE_END, "opcode:end");
 }
 
 void writeLimits(raw_ostream &os, const WasmLimits &limits) {
   writeU8(os, limits.Flags, "limits flags");
-  writeUleb128(os, limits.Initial, "limits initial");
+  writeUleb128(os, limits.Minimum, "limits min");
   if (limits.Flags & WASM_LIMITS_FLAG_HAS_MAX)
     writeUleb128(os, limits.Maximum, "limits max");
 }
 
 void writeGlobalType(raw_ostream &os, const WasmGlobalType &type) {
   // TODO: Update WasmGlobalType to use ValType and remove this cast.
   writeValueType(os, ValType(type.Type), "global type");
   writeU8(os, type.Mutable, "global mutable");

llvm/include/llvm/BinaryFormat/Wasm.h

 struct WasmExport {
   StringRef Name;
   uint8_t Kind;
   uint32_t Index;
 };
 
 struct WasmLimits {
   uint8_t Flags;
-  uint64_t Initial;
+  uint64_t Minimum;
   uint64_t Maximum;
 };
 
 struct WasmTableType {
   uint8_t ElemType;
   WasmLimits Limits;
 };
 

llvm/include/llvm/ObjectYAML/WasmYAML.h

 LLVM_YAML_STRONG_TYPEDEF(uint32_t, FeaturePolicyPrefix)
 
 struct FileHeader {
   yaml::Hex32 Version;
 };
 
 struct Limits {
   LimitFlags Flags;
-  yaml::Hex32 Initial;
+  yaml::Hex32 Minimum;
   yaml::Hex32 Maximum;
 };
 
 struct Table {
   TableType ElemType;
   Limits TableLimits;
   uint32_t Index;
 };

llvm/lib/MC/WasmObjectWriter.cpp

void WasmObjectWriter::writeTableSection(ArrayRef<wasm::WasmTable> Tables) {
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_TABLE);
 
   encodeULEB128(Tables.size(), W->OS);
   for (const wasm::WasmTable &Table : Tables) {
     encodeULEB128(Table.Type.ElemType, W->OS);
     encodeULEB128(Table.Type.Limits.Flags, W->OS);
-    encodeULEB128(Table.Type.Limits.Initial, W->OS);
+    encodeULEB128(Table.Type.Limits.Minimum, 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())

llvm/lib/Object/WasmObjectFile.cpp

return make_error<GenericBinaryError>("invalid init_expr",
                                           object_error::parse_failed);
   }
   return Error::success();
 }
 
 static wasm::WasmLimits readLimits(WasmObjectFile::ReadContext &Ctx) {
   wasm::WasmLimits Result;
   Result.Flags = readVaruint32(Ctx);
-  Result.Initial = readVaruint64(Ctx);
+  Result.Minimum = readVaruint64(Ctx);
   if (Result.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
     Result.Maximum = readVaruint64(Ctx);
   return Result;
 }
 
 static wasm::WasmTableType readTableType(WasmObjectFile::ReadContext &Ctx) {
   wasm::WasmTableType TableType;
   TableType.ElemType = readUint8(Ctx);

llvm/lib/ObjectYAML/WasmEmitter.cpp

 static int writeStringRef(const StringRef &Str, raw_ostream &OS) {
   encodeULEB128(Str.size(), OS);
   OS << Str;
   return 0;
 }
 
 static int writeLimits(const WasmYAML::Limits &Lim, raw_ostream &OS) {
   writeUint8(OS, Lim.Flags);
-  encodeULEB128(Lim.Initial, OS);
+  encodeULEB128(Lim.Minimum, OS);
   if (Lim.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
     encodeULEB128(Lim.Maximum, OS);
   return 0;
 }
 
 void WasmWriter::reportError(const Twine &Msg) {
   ErrHandler(Msg);
   HasError = true;

llvm/lib/ObjectYAML/WasmYAML.cpp

void MappingTraits<WasmYAML::LocalDecl>::mapping(
   IO.mapRequired("Type", LocalDecl.Type);
   IO.mapRequired("Count", LocalDecl.Count);
 }
 
 void MappingTraits<WasmYAML::Limits>::mapping(IO &IO,
                                               WasmYAML::Limits &Limits) {
   if (!IO.outputting() || Limits.Flags)
     IO.mapOptional("Flags", Limits.Flags);
-  IO.mapRequired("Initial", Limits.Initial);
+  IO.mapRequired("Minimum", Limits.Minimum);
   if (!IO.outputting() || Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
     IO.mapOptional("Maximum", Limits.Maximum);
 }
 
 void MappingTraits<WasmYAML::ElemSegment>::mapping(
     IO &IO, WasmYAML::ElemSegment &Segment) {
   if (!IO.outputting() || Segment.Flags)
     IO.mapOptional("Flags", Segment.Flags);

llvm/test/CodeGen/WebAssembly/call-indirect.ll

define void @call_indirect_void(void ()* %callee) {
   ret void
 }
 
 ; OBJ:    Imports:
 ; OBJ-NEXT:      - Module:          env
 ; OBJ-NEXT:        Field:           __linear_memory
 ; OBJ-NEXT:        Kind:            MEMORY
 ; OBJ-NEXT:        Memory:
-; OBJ-NEXT:          Initial:         0x0
+; OBJ-NEXT:          Minimum:         0x0
 ; OBJ-NEXT:      - Module:          env
 ; OBJ-NEXT:        Field:           __indirect_function_table
 ; OBJ-NEXT:        Kind:            TABLE

llvm/test/CodeGen/WebAssembly/function-pointer64.ll

 ; CHECK-NEXT: call foo
 
 
 ; Check we're emitting a 64-bit relocs for the call_indirect, the
 ; `i64.const bar` reference in code, and the global.
 
 ; YAML:      Memory:
 ; YAML-NEXT:   Flags:   [ IS_64 ]
-; YAML-NEXT:   Initial: 0x1
+; YAML-NEXT:   Minimum: 0x1
 
 ; YAML:      - Type:   CODE
 ; YAML:      - Type:   R_WASM_TABLE_INDEX_SLEB64
 ; YAML-NEXT:   Index:  0
 ; YAML-NEXT:   Offset: 0x16
 ; YAML:      - Type:   R_WASM_TABLE_INDEX_SLEB64
 ; YAML-NEXT:   Index:  0
 ; YAML-NEXT:   Offset: 0x29
 
 ; YAML:      - Type:   DATA
 ; YAML:      - Type:   R_WASM_TABLE_INDEX_I64
 ; YAML-NEXT:   Index:  0
 ; YAML-NEXT:   Offset: 0x6

llvm/test/MC/WebAssembly/assembler-binary.ll

 ; CHECK-NEXT:         ParamTypes:      []
 ; CHECK-NEXT:         ReturnTypes:     []
 ; CHECK-NEXT:   - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __linear_memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Memory:
-; CHECK-NEXT:           Initial:         0x0
+; CHECK-NEXT:           Minimum:         0x0
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           bar
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:

llvm/test/MC/WebAssembly/call-indirect-relocs.s

 # BIN-NEXT:           - F64
 # BIN-NEXT:         ReturnTypes:     []
 # BIN-NEXT:   - Type:            IMPORT
 # BIN-NEXT:     Imports:
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __linear_memory
 # BIN-NEXT:         Kind:            MEMORY
 # BIN-NEXT:         Memory:
-# BIN-NEXT:           Initial:         0x0
+# BIN-NEXT:           Minimum:         0x0
 # BIN-NEXT:   - Type:            FUNCTION
 # BIN-NEXT:     FunctionTypes:   [ 0 ]
 # BIN-NEXT:   - Type:            TABLE
 # BIN-NEXT:     Tables:
 # BIN-NEXT:       - Index:           0
 # BIN-NEXT:         ElemType:        FUNCREF
 # BIN-NEXT:         Limits:
-# BIN-NEXT:           Initial:         0x0
+# BIN-NEXT:           Minimum:         0x0
 # BIN-NEXT:   - Type:            CODE
 # BIN-NEXT:     Relocations:
 # BIN-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
 # BIN-NEXT:         Index:           1
 # BIN-NEXT:         Offset:          0x11
 # BIN-NEXT:       - Type:            R_WASM_TABLE_NUMBER_LEB
 # BIN-NEXT:         Index:           1
 # BIN-NEXT:         Offset:          0x16

llvm/test/MC/WebAssembly/comdat.ll

 ; CHECK-NEXT:         ReturnTypes:
 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:   - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __linear_memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Memory:
-; CHECK-NEXT:           Initial:         0x1
+; CHECK-NEXT:           Minimum:         0x1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           funcImport
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0 ]
 ; CHECK-NEXT:  - Type:            DATACOUNT
 ; CHECK-NEXT:    Count:           1

llvm/test/MC/WebAssembly/data-section.s

 # BIN-NEXT:           - I32
 # BIN-NEXT:   - Type:            IMPORT
 # BIN-NEXT:     Imports:
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __linear_memory
 # BIN-NEXT:         Kind:            MEMORY
 # BIN-NEXT:         Memory:
 # BIN64-NEXT:         Flags:           [ IS_64 ]
-# BIN-NEXT:           Initial:         0x1
+# BIN-NEXT:           Minimum:         0x1
 # BIN-NEXT:   - Type:            FUNCTION
 # BIN-NEXT:     FunctionTypes:   [ 0 ]
 # BIN-NEXT:   - Type:            DATACOUNT
 # BIN-NEXT:     Count:           1
 # BIN-NEXT:   - Type:            CODE
 # BIN-NEXT:     Relocations:
 # BIN-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB
 # BIN-NEXT:         Index:           1

llvm/test/MC/WebAssembly/global-ctor-dtor.ll

 ]
 
 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __linear_memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Memory:
-; CHECK-NEXT:           Initial:         0x1
+; CHECK-NEXT:           Minimum:         0x1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           func3
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __cxa_atexit
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        2

 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __indirect_function_table
 ; CHECK-NEXT:         Kind:            TABLE
 ; CHECK-NEXT:         Table:
 ; CHECK-NEXT:           Index:           0
 ; CHECK-NEXT:           ElemType:        FUNCREF
 ; CHECK-NEXT:           Limits:
-; CHECK-NEXT:             Initial:         0x2
+; CHECK-NEXT:             Minimum:         0x2
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 1 ]
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 5, 7 ]

llvm/test/MC/WebAssembly/reloc-pic.s

 # CHECK-NEXT:         ReturnTypes:
 # CHECK-NEXT:           - I32
 # CHECK-NEXT:   - Type:            IMPORT
 # CHECK-NEXT:     Imports:
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           __linear_memory
 # CHECK-NEXT:         Kind:            MEMORY
 # CHECK-NEXT:         Memory:
-# CHECK-NEXT:           Initial:         0x1
+# CHECK-NEXT:           Minimum:         0x1
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           default_func
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         SigIndex:        0
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           __indirect_function_table
 # CHECK-NEXT:         Kind:            TABLE
 # CHECK-NEXT:         Table:
 # CHECK-NEXT:           Index:           0
 # CHECK-NEXT:           ElemType:        FUNCREF
 # CHECK-NEXT:           Limits:
-# CHECK-NEXT:             Initial:         0x1
+# CHECK-NEXT:             Minimum:         0x1
 # CHECK-NEXT:       - Module:          GOT.mem
 # CHECK-NEXT:         Field:           default_data
 # CHECK-NEXT:         Kind:            GLOBAL
 # CHECK-NEXT:         GlobalType:      I32
 # CHECK-NEXT:         GlobalMutable:   true
 # CHECK-NEXT:       - Module:          GOT.func
 # CHECK-NEXT:         Field:           default_func
 # CHECK-NEXT:         Kind:            GLOBAL

llvm/test/MC/WebAssembly/tables.s

table_fill:
     table.fill table1
     end_function
 
 #      BIN:  - Type:            TABLE
 # BIN-NEXT:    Tables:
 # BIN-NEXT:      - Index:           0
 # BIN-NEXT:        ElemType:        EXTERNREF
 # BIN-NEXT:        Limits:
-# BIN-NEXT:          Initial:         0x0
+# BIN-NEXT:          Minimum:         0x0
 # BIN-NEXT:      - Index:           1
 # BIN-NEXT:        ElemType:        FUNCREF
 # BIN-NEXT:        Limits:
-# BIN-NEXT:          Initial:         0x0
+# BIN-NEXT:          Minimum:         0x0
 # BIN-NEXT:      - Index:           2
 # BIN-NEXT:        ElemType:        FUNCREF
 # BIN-NEXT:        Limits:
-# BIN-NEXT:          Initial:         0x0
+# BIN-NEXT:          Minimum:         0x0
 # BIN-NEXT:      - Index:           3
 # BIN-NEXT:        ElemType:        FUNCREF
 # BIN-NEXT:        Limits:
-# BIN-NEXT:          Initial:         0x0
+# BIN-NEXT:          Minimum:         0x0
 
 #      BIN:  - Type:            CODE
 # BIN-NEXT:    Relocations:
 # BIN-NEXT:      - Type:            R_WASM_TABLE_NUMBER_LEB
 # BIN-NEXT:        Index:           2
 # BIN-NEXT:        Offset:          0x9
 # BIN-NEXT:      - Type:            R_WASM_TABLE_NUMBER_LEB
 # BIN-NEXT:        Index:           2

llvm/test/MC/WebAssembly/type-index.s

 # BIN-NEXT:         ReturnTypes:
 # BIN-NEXT:           - F64
 # BIN-NEXT:   - Type:            IMPORT
 # BIN-NEXT:     Imports:
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __linear_memory
 # BIN-NEXT:         Kind:            MEMORY
 # BIN-NEXT:         Memory:
-# BIN-NEXT:           Initial:         0x0
+# BIN-NEXT:           Minimum:         0x0
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __indirect_function_table
 # BIN-NEXT:         Kind:            TABLE
 # BIN-NEXT:         Table:
 # BIN-NEXT:           Index:           0
 # BIN-NEXT:           ElemType:        FUNCREF
 # BIN-NEXT:           Limits:
-# BIN-NEXT:             Initial:         0x0
+# BIN-NEXT:             Minimum:         0x0
 # BIN-NEXT:   - Type:            FUNCTION
 # BIN-NEXT:     FunctionTypes:   [ 0 ]
 # BIN-NEXT:   - Type:            CODE
 # BIN-NEXT:     Relocations:
 # BIN-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
 # BIN-NEXT:         Index:           1
 # BIN-NEXT:         Offset:          0x4
 # BIN-NEXT:       - Type:            R_WASM_TABLE_NUMBER_LEB

llvm/test/MC/WebAssembly/wasm64.s

 # BIN-NEXT:         ReturnTypes:     []
 # BIN-NEXT:   - Type:            IMPORT
 # BIN-NEXT:     Imports:
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __linear_memory
 # BIN-NEXT:         Kind:            MEMORY
 # BIN-NEXT:         Memory:
 # BIN-NEXT:           Flags:           [ IS_64 ]
-# BIN-NEXT:           Initial:         0x1
+# BIN-NEXT:           Minimum:         0x1
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           myglob64
 # BIN-NEXT:         Kind:            GLOBAL
 # BIN-NEXT:         GlobalType:      I64
 # BIN-NEXT:         GlobalMutable:   true
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __stack_pointer
 # BIN-NEXT:         Kind:            GLOBAL

llvm/test/MC/WebAssembly/weak-alias.s

 # CHECK-NEXT:         ReturnTypes:
 # CHECK-NEXT:           - I32
 # CHECK-NEXT:   - Type:            IMPORT
 # CHECK-NEXT:     Imports:
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           __linear_memory
 # CHECK-NEXT:         Kind:            MEMORY
 # CHECK-NEXT:         Memory:
-# CHECK-NEXT:           Initial:         0x1
+# CHECK-NEXT:           Minimum:         0x1
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           __indirect_function_table
 # CHECK-NEXT:         Kind:            TABLE
 # CHECK-NEXT:         Table:
 # CHECK-NEXT:           Index:           0
 # CHECK-NEXT:           ElemType:        FUNCREF
 # CHECK-NEXT:           Limits:
-# CHECK-NEXT:             Initial:         0x1
+# CHECK-NEXT:             Minimum:         0x1
 # CHECK-NEXT:   - Type:            FUNCTION
 # CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0 ]
 # CHECK-NEXT:   - Type:            ELEM
 # CHECK-NEXT:     Segments:
 # CHECK-NEXT:       - Offset:
 # CHECK-NEXT:           Opcode:          I32_CONST
 # CHECK-NEXT:           Value:           1
 # CHECK-NEXT:         Functions:       [ 0 ]

 # REF-NEXT:         ReturnTypes:
 # REF-NEXT:           - I32
 # REF-NEXT:   - Type:            IMPORT
 # REF-NEXT:     Imports:
 # REF-NEXT:       - Module:          env
 # REF-NEXT:         Field:           __linear_memory
 # REF-NEXT:         Kind:            MEMORY
 # REF-NEXT:         Memory:
-# REF-NEXT:           Initial:         0x1
+# REF-NEXT:           Minimum:         0x1
 # REF-NEXT:       - Module:          env
 # REF-NEXT:         Field:           __indirect_function_table
 # REF-NEXT:         Kind:            TABLE
 # REF-NEXT:         Table:
 # REF-NEXT:           Index:           0
 # REF-NEXT:           ElemType:        FUNCREF
 # REF-NEXT:           Limits:
-# REF-NEXT:             Initial:         0x1
+# REF-NEXT:             Minimum:         0x1
 # REF-NEXT:   - Type:            FUNCTION
 # REF-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0 ]
 # REF-NEXT:   - Type:            ELEM
 # REF-NEXT:     Segments:
 # REF-NEXT:       - Offset:
 # REF-NEXT:           Opcode:          I32_CONST
 # REF-NEXT:           Value:           1
 # REF-NEXT:         Functions:       [ 0 ]

llvm/test/Object/wasm-relocs-and-producers.yaml

Signatures:
         ParamTypes:      []
         ReturnTypes:     []
   - Type:            IMPORT
     Imports:
       - Module:          env
         Field:           __linear_memory
         Kind:            MEMORY
         Memory:
-          Initial:         0x00000000
+          Minimum:         0x00000000
       - Module:          env
         Field:           __indirect_function_table
         Kind:            TABLE
         Table:
           Index:           0
           ElemType:        FUNCREF
           Limits:
-            Initial:         0x00000000
+            Minimum:         0x00000000
   - Type:            FUNCTION
     FunctionTypes:   [ 0 ]
   - Type:            CODE
     Relocations:
       - Type:            R_WASM_FUNCTION_INDEX_LEB
         Index:           0
         Offset:          0x00000004
     Functions:

llvm/test/ObjectYAML/wasm/data_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            MEMORY
     Memories:
-      - Initial:         0x00000003
+      - Minimum:         0x00000003
   - Type:            DATA
     Segments:
       - InitFlags:        0
         Offset:
           Opcode:          I32_CONST
           Value:           4
         Content:         '10001000'
       - InitFlags:       1

llvm/test/ObjectYAML/wasm/elem_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TABLE
     Tables:         
       - Index:             0
         ElemType:          FUNCREF
         Limits:
           Flags:           [ HAS_MAX ]
-          Initial:         0x00000010
+          Minimum:         0x00000010
           Maximum:         0x00000011
   - Type:            ELEM
     Segments:
       - Offset:
           Opcode:        I32_CONST
           Value:         3
         Functions:
           - 1

llvm/test/ObjectYAML/wasm/import_memory_shared.yaml

Signatures:
           - I32
   - Type:            IMPORT
     Imports:
       - Module:          foo
         Field:           imported_memory
         Kind:            MEMORY
         Memory:
           Flags:           [ HAS_MAX, IS_SHARED ]
-          Initial:         0x00000010
+          Minimum:         0x00000010
           Maximum:         0x00000011
 
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x1
 # CHECK: Sections:
 # CHECK:   - Type:            IMPORT
 # CHECK:     Imports:
 # CHECK:       - Module:          foo
 # CHECK:         Field:           imported_memory
 # CHECK:         Kind:            MEMORY
 # CHECK:         Memory:
 # CHECK:           Flags:           [ HAS_MAX, IS_SHARED ]
-# CHECK:           Initial:         0x10
+# CHECK:           Minimum:         0x10
 # CHECK:           Maximum:         0x11
 # CHECK: ...

llvm/test/ObjectYAML/wasm/import_section.yaml

Imports:
         Kind:            GLOBAL
         GlobalType:      I32
         GlobalMutable:   false
       - Module:          foo
         Field:           imported_memory
         Kind:            MEMORY
         Memory:
           Flags:           [ HAS_MAX ]
-          Initial:         0x00000010
+          Minimum:         0x00000010
           Maximum:         0x00000011
       - Module:          foo
         Field:           imported_table
         Kind:            TABLE
         Table:
           Index:         0
           ElemType:      FUNCREF
           Limits:
             Flags:           [ HAS_MAX ]
-            Initial:         0x00000020
+            Minimum:         0x00000020
             Maximum:         0x00000022
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x1
 # CHECK: Sections:
 # CHECK:   - Type:            IMPORT
 # CHECK:     Imports:
 # CHECK:       - Module:          foo
 # CHECK:         Field:           imported_function
 # CHECK:         Kind:            FUNCTION
 # CHECK:         SigIndex:        0
 # CHECK:       - Module:          fiz
 # CHECK:         Field:           imported_global
 # CHECK:         Kind:            GLOBAL
 # CHECK:         GlobalType:      I32
 # CHECK:         GlobalMutable:   false
 # CHECK:       - Module:          foo
 # CHECK:         Field:           imported_memory
 # CHECK:         Kind:            MEMORY
 # CHECK:         Memory:
 # CHECK:           Flags:           [ HAS_MAX ]
-# CHECK:           Initial:         0x10
+# CHECK:           Minimum:         0x10
 # CHECK:           Maximum:         0x11
 # CHECK:       - Module:          foo
 # CHECK:         Field:           imported_table
 # CHECK:         Kind:            TABLE
 # CHECK:         Table:
 # CHECK:           ElemType:      FUNCREF
 # CHECK:           Limits:
 # CHECK:             Flags:           [ HAS_MAX ]
-# CHECK:             Initial:         0x20
+# CHECK:             Minimum:         0x20
 # CHECK:             Maximum:         0x22
 # CHECK: ...

llvm/test/ObjectYAML/wasm/memory_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            MEMORY
     Memories:         
       - Flags:           [ HAS_MAX ]
-        Initial:         0x00000002
+        Minimum:         0x00000002
         Maximum:         0x000000FF
-      - Initial:         0x00000003
+      - Minimum:         0x00000003
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x1
 # CHECK: Sections:
 # CHECK:   - Type:            MEMORY
 # CHECK:     Memories:         
 # CHECK:       - Flags:            [ HAS_MAX ]
-# CHECK:         Initial:          0x2
+# CHECK:         Minimum:          0x2
 # CHECK:         Maximum:          0xFF
-# CHECK:       - Initial:          0x3
+# CHECK:       - Minimum:          0x3
 # CHECK: ...

llvm/test/ObjectYAML/wasm/multiple-tables.yaml

- Type:            IMPORT
     Imports:
       - Module:          env
         Field:           table_a
         Kind:            TABLE
         Table:
           Index:           0
           ElemType:        FUNCREF
           Limits:
-            Initial:         0x0
+            Minimum:         0x0
   - Type:            FUNCTION
     FunctionTypes:   [ 0 ]
   - Type:            TABLE
     Tables:
       - Index:           1
         ElemType:        FUNCREF
         Limits:
-          Initial:         0x0
+          Minimum:         0x0
       - Index:           2
         ElemType:        EXTERNREF
         Limits:
-          Initial:         0x0
+          Minimum:         0x0
       - Index:           3
         ElemType:        FUNCREF
         Limits:
           Flags:           [ HAS_MAX ]
-          Initial:         0x3
+          Minimum:         0x3
           Maximum:         0x3
   - Type:            EXPORT
     Exports:
       - Name:            table_b
         Kind:            TABLE
         Index:           1
       - Name:            table_c
         Kind:            TABLE

 # CHECK-NEXT:     Imports:
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           table_a
 # CHECK-NEXT:         Kind:            TABLE
 # CHECK-NEXT:         Table:
 # CHECK-NEXT:           Index:           0
 # CHECK-NEXT:           ElemType:        FUNCREF
 # CHECK-NEXT:           Limits:
-# CHECK-NEXT:             Initial:         0x0
+# CHECK-NEXT:             Minimum:         0x0
 # CHECK-NEXT:   - Type:            FUNCTION
 # CHECK-NEXT:     FunctionTypes:   [ 0 ]
 # CHECK-NEXT:   - Type:            TABLE
 # CHECK-NEXT:     Tables:
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         ElemType:        FUNCREF
 # CHECK-NEXT:         Limits:
-# CHECK-NEXT:           Initial:         0x0
+# CHECK-NEXT:           Minimum:         0x0
 # CHECK-NEXT:       - Index:           2
 # CHECK-NEXT:         ElemType:        EXTERNREF
 # CHECK-NEXT:         Limits:
-# CHECK-NEXT:           Initial:         0x0
+# CHECK-NEXT:           Minimum:         0x0
 # CHECK-NEXT:       - Index:           3
 # CHECK-NEXT:         ElemType:        FUNCREF
 # CHECK-NEXT:         Limits:
 # CHECK-NEXT:           Flags:           [ HAS_MAX ]
-# CHECK-NEXT:           Initial:         0x3
+# CHECK-NEXT:           Minimum:         0x3
 # CHECK-NEXT:           Maximum:         0x3
 # CHECK-NEXT:   - Type:            EXPORT
 # CHECK-NEXT:     Exports:
 # CHECK-NEXT:       - Name:            table_b
 # CHECK-NEXT:         Kind:            TABLE
 # CHECK-NEXT:         Index:           1
 # CHECK-NEXT:       - Name:            table_c
 # CHECK-NEXT:         Kind:            TABLE

llvm/test/ObjectYAML/wasm/table_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TABLE
     Tables:         
       - Index:           0
         ElemType:        FUNCREF
         Limits:
           Flags:           [ HAS_MAX ]
-          Initial:         0x00000010
+          Minimum:         0x00000010
           Maximum:         0x00000011
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x1
 # CHECK: Sections:
 # CHECK:  - Type:            TABLE
 # CHECK:    Tables:         
 # CHECK:      - Index:           0
 # CHECK:        ElemType:        FUNCREF
 # CHECK:        Limits:
 # CHECK:          Flags:           [ HAS_MAX ]
-# CHECK:          Initial:         0x10
+# CHECK:          Minimum:         0x10
 # CHECK:          Maximum:         0x11
 # CHECK: ...

llvm/test/tools/llvm-readobj/wasm/wasm-imports.test

Signatures:
         ParamTypes:      []
         ReturnTypes:     []
   - Type:            IMPORT
     Imports:         
       - Module:          env
         Field:           __linear_memory
         Kind:            MEMORY
         Memory:          
-          Initial:         0x00000000
+          Minimum:         0x00000000
       - Module:          env
         Field:           __indirect_function_table
         Kind:            TABLE
         Table:           
           Index:           0
           ElemType:        FUNCREF
           Limits:          
-            Initial:         0x00000000
+            Minimum:         0x00000000
       - Module:          red
         Field:           foo
         Kind:            FUNCTION
         SigIndex:        1
       - Module:          env
         Field:           green
         Kind:            FUNCTION
         SigIndex:        1

llvm/tools/llvm-readobj/WasmDumper.cpp

case wasm::WASM_SEC_DATA: {
           llvm_unreachable("unknown init expr opcode");
       }
       break;
     }
     case wasm::WASM_SEC_MEMORY:
       ListScope Group(W, "Memories");
       for (const wasm::WasmLimits &Memory : Obj->memories()) {
         DictScope Group(W, "Memory");
-        W.printNumber("InitialPages", Memory.Initial);
+        W.printNumber("MinPages", Memory.Minimum);
         if (Memory.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX) {
           W.printNumber("MaxPages", WasmSec.Offset);
         }
       }
       break;
     }
 
     if (opts::SectionRelocations) {

llvm/tools/obj2yaml/wasm2yaml.cpp

public:
   dumpCustomSection(const WasmSection &WasmSec);
 };
 
 } // namespace
 
 static WasmYAML::Limits makeLimits(const wasm::WasmLimits &Limits) {
   WasmYAML::Limits L;
   L.Flags = Limits.Flags;
-  L.Initial = Limits.Initial;
+  L.Minimum = Limits.Minimum;
   L.Maximum = Limits.Maximum;
   return L;
 }
 
 static WasmYAML::Table makeTable(uint32_t Index,
                                  const wasm::WasmTableType &Type) {
   WasmYAML::Table T;
   T.Index = Index;