test/lit/passes/toolchain-inlining.wast

;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.

;; RUN: foreach %s %t wasm-opt --inlining -S -o - | filecheck %s

(module
  ;; CHECK:      (type $0 (func (result i32)))

  ;; CHECK:      (type $1 (func))

  ;; CHECK:      (@binaryen.inline "\00")
  ;; CHECK-NEXT: (func $never (result i32)
  ;; CHECK-NEXT:  (i32.const 42)
  ;; CHECK-NEXT: )
  (@binaryen.inline "\00")
  (func $never (result i32)
    (i32.const 42)
  )

  (func $never-unannotated (result i32)
    ;; Identical to above, but without the annotation. This will be inlined,
    ;; showing the hint works.
    (i32.const 42)
  )

  (@binaryen.inline "\7f")
  (func $always (result i32)
    (local $x i32)
    ;; Add code that normally makes us not inline.
    (loop $loop
      (local.set $x
        (i32.add
          (local.get $x)
          (i32.const 1)
        )
      )
      (br_if $loop
        (i32.eqz
          (local.get $x)
        )
      )
    )
    (local.get $x)
  )

  ;; CHECK:      (func $always-unannotated (result i32)
  ;; CHECK-NEXT:  (local $x i32)
  ;; CHECK-NEXT:  (loop $loop
  ;; CHECK-NEXT:   (local.set $x
  ;; CHECK-NEXT:    (i32.add
  ;; CHECK-NEXT:     (local.get $x)
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (br_if $loop
  ;; CHECK-NEXT:    (i32.eqz
  ;; CHECK-NEXT:     (local.get $x)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $x)
  ;; CHECK-NEXT: )
  (func $always-unannotated (result i32)
    (local $x i32)
    ;; Identical to above, but without the annotation. This will not be inlined,
    ;; showing the hint works.
    (loop $loop
      (local.set $x
        (i32.add
          (local.get $x)
          (i32.const 1)
        )
      )
      (br_if $loop
        (i32.eqz
          (local.get $x)
        )
      )
    )
    (local.get $x)
  )

  ;; CHECK:      (func $caller
  ;; CHECK-NEXT:  (local $0 i32)
  ;; CHECK-NEXT:  (local $1 i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (call $never)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block $__inlined_func$never-unannotated (result i32)
  ;; CHECK-NEXT:    (i32.const 42)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block $__inlined_func$always$1 (result i32)
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (block (result i32)
  ;; CHECK-NEXT:     (loop $loop
  ;; CHECK-NEXT:      (local.set $0
  ;; CHECK-NEXT:       (i32.add
  ;; CHECK-NEXT:        (local.get $0)
  ;; CHECK-NEXT:        (i32.const 1)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (br_if $loop
  ;; CHECK-NEXT:       (i32.eqz
  ;; CHECK-NEXT:        (local.get $0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.get $0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block $__inlined_func$always$2 (result i32)
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (block (result i32)
  ;; CHECK-NEXT:     (loop $loop0
  ;; CHECK-NEXT:      (local.set $1
  ;; CHECK-NEXT:       (i32.add
  ;; CHECK-NEXT:        (local.get $1)
  ;; CHECK-NEXT:        (i32.const 1)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (br_if $loop0
  ;; CHECK-NEXT:       (i32.eqz
  ;; CHECK-NEXT:        (local.get $1)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.get $1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (call $always-unannotated)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (call $always-unannotated)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $caller
    (drop
      (call $never)
    )
    (drop
      (call $never-unannotated)
    )
    ;; We need multiple calls here, to avoid the 'single-caller rule that
    ;; always inlines anyhow.
    (drop
      (call $always)
    )
    (drop
      (call $always)
    )
    (drop
      (call $always-unannotated)
    )
    (drop
      (call $always-unannotated)
    )
  )
)