[WebAssembly] Remove tabs in tests (NFC)

[aheejin]

Summary

This replaces tabs with 2 spaces.

[aheejin]

Ping. Would this be ok?

[tlively]

Sounds good to me!

[sbc100]

Isn't this because there are tabs in the output of these tools? In those cases I think its fine for the tabs to exist in the test expectations (even if they are ignored). Makes it easier to copy and paste output into expectations.

[aheejin]

In D58956#1419338, @sbc100 wrote:

Isn't this because there are tabs in the output of these tools? In those cases I think its fine for the tabs to exist in the test expectations (even if they are ignored). Makes it easier to copy and paste output into expectations.

Yes. And that's the reason I wanted to here people's opinions. The reason I wanted to remove them was we were not consistent on that; most of out CHECK lines don't have tabs, only some of them do. So I thought like, if we are not gonna make very CHECK line have tabs, maybe remove them all is consistent. But anyway, as you said, these are generated test lines after all and I don't feel strongly about removing them. I was mostly bored last night. :$

[sbc100]

I'm tempted to just say leave these as is. Unless we plan to enforce a policy here, which I'm not convinced we should.

[aardappel]

It would be awesome if we could somehow force tabs to be errors, frankly. Or is there some other automatic way to detect them? Or show them in code review?

I know this changes is abandoned, but I am in favor of it.

[tlively]

In D58956#1421823, @aardappel wrote:

It would be awesome if we could somehow force tabs to be errors, frankly. Or is there some other automatic way to detect them? Or show them in code review?

I know this changes is abandoned, but I am in favor of it.

+1. Perhaps we could all agree on a stand git pre-commit hook. I use one that doesn't let me commit unless I've run git clang-format, and I'm sure it could be extended to check for the absence of tabs as well.

[sbc100]

In D58956#1421823, @aardappel wrote:

It would be awesome if we could somehow force tabs to be errors, frankly. Or is there some other automatic way to detect them? Or show them in code review?

I know this changes is abandoned, but I am in favor of it.

But what about then the tabs form part of the program under test's output? Whats that argument against allowing them? Surely it makes it easier if one can (or at least has the option to) simply copy and paste the expectations?

[tlively]

In D58956#1421908, @sbc100 wrote:

But what about then the tabs form part of the program under test's output? Whats that argument against allowing them? Surely it makes it easier if one can (or at least has the option to) simply copy and paste the expectations?

Yeah, that's fair. And I've never seen an issue where a tab appeared in a source file. I have had issues with white space at the ends of lines in tests, though. My editor likes to automatically remove them whenever I save those files, which causes extra noise in my diffs that I have to manually undo. So a policy against end-of-line white space would actually be helpful for me.

test/CodeGen/WebAssembly/custom-sections.ll

 
 !llvm.module.flags = !{!4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 
 !llvm.dbg.cu = !{!5}
 !5 = distinct !DICompileUnit(language: DW_LANG_C99, file: !6)
 !6 = !DIFile(filename: "test", directory: "testdir")
 
-; CHECK:      .section  .custom_section.red,"",@
-; CHECK-NEXT: .ascii  "foo"
+; CHECK:      .section  .custom_section.red,"",@
+; CHECK-NEXT: .ascii  "foo"
 
-; CHECK:      .section  .custom_section.green,"",@
-; CHECK-NEXT: .ascii  "bar"
+; CHECK:      .section  .custom_section.green,"",@
+; CHECK-NEXT: .ascii  "bar"
 
-; CHECK:      .section  .custom_section.green,"",@
-; CHECK-NEXT: .ascii  "qux"
+; CHECK:      .section  .custom_section.green,"",@
+; CHECK-NEXT: .ascii  "qux"
 
-; CHECK:      .section  .custom_section.producers,"",@
-; CHECK-NEXT: .int8 2
-; CHECK-NEXT: .int8 8
-; CHECK-NEXT: .ascii  "language"
-; CHECK-NEXT: .int8 1
-; CHECK-NEXT: .int8 3
-; CHECK-NEXT: .ascii  "C99"
-; CHECK-NEXT: .int8 0
-; CHECK-NEXT: .int8 12
-; CHECK-NEXT: .ascii  "processed-by"
-; CHECK-NEXT: .int8 1
-; CHECK-NEXT: .int8 5
-; CHECK-NEXT: .ascii  "clang"
-; CHECK-NEXT: .int8 3
-; CHECK-NEXT: .ascii  "123"
+; CHECK:      .section  .custom_section.producers,"",@
+; CHECK-NEXT: .int8  2
+; CHECK-NEXT: .int8  8
+; CHECK-NEXT: .ascii  "language"
+; CHECK-NEXT: .int8  1
+; CHECK-NEXT: .int8  3
+; CHECK-NEXT: .ascii  "C99"
+; CHECK-NEXT: .int8  0
+; CHECK-NEXT: .int8  12
+; CHECK-NEXT: .ascii  "processed-by"
+; CHECK-NEXT: .int8  1
+; CHECK-NEXT: .int8  5
+; CHECK-NEXT: .ascii  "clang"
+; CHECK-NEXT: .int8  3
+; CHECK-NEXT: .ascii  "123"

test/CodeGen/WebAssembly/f16.ll

 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers | FileCheck %s
 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -fast-isel | FileCheck %s
 
 ; Test that f16 is expanded.
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; CHECK-LABEL: demote:
 ; CHECK-NEXT: .functype demote (f32) -> (f32){{$}}
-; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}}
-; CHECK-NEXT: i32.call  $push[[L1:[0-9]+]]=, __gnu_f2h_ieee, $pop[[L0]]{{$}}
-; CHECK-NEXT: f32.call  $push[[L2:[0-9]+]]=, __gnu_h2f_ieee, $pop[[L1]]{{$}}
-; CHECK-NEXT: return    $pop[[L2]]{{$}}
+; CHECK-NEXT: local.get  $push[[L0:[0-9]+]]=, 0{{$}}
+; CHECK-NEXT: i32.call  $push[[L1:[0-9]+]]=, __gnu_f2h_ieee, $pop[[L0]]{{$}}
+; CHECK-NEXT: f32.call  $push[[L2:[0-9]+]]=, __gnu_h2f_ieee, $pop[[L1]]{{$}}
+; CHECK-NEXT: return    $pop[[L2]]{{$}}
 define half @demote(float %f) {
     %t = fptrunc float %f to half
     ret half %t
 }
 
 ; CHECK-LABEL: promote:
 ; CHECK-NEXT: .functype promote (f32) -> (f32){{$}}
-; CHECK-NEXT: local.get $push0=, 0{{$}}
-; CHECK-NEXT: return    $pop0{{$}}
+; CHECK-NEXT: local.get  $push0=, 0{{$}}
+; CHECK-NEXT: return    $pop0{{$}}
 define float @promote(half %f) {
     %t = fpext half %f to float
     ret float %t
 }

test/CodeGen/WebAssembly/fast-isel-i24.ll

 ; RUN: llc < %s -O0 -wasm-keep-registers
 ; PR36564
 ; PR37546
 
 ; Test that fast-isel properly copes with i24 arguments and return types.
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; CHECK-LABEL: add:
 ; CHECK-NEXT: .functype add (i32, i32) -> (i32){{$}}
-; CHECK-NEXT: local.get $push2=, 0{{$}}
-; CHECK-NEXT: local.get $push1=, 1{{$}}
-; CHECK-NEXT: i32.add   $push0=, $pop2, $pop1{{$}}
+; CHECK-NEXT: local.get  $push2=, 0{{$}}
+; CHECK-NEXT: local.get  $push1=, 1{{$}}
+; CHECK-NEXT: i32.add   $push0=, $pop2, $pop1{{$}}
 ; CHECK-NEXT: end_function
 define i24 @add(i24 %x, i24 %y) {
     %z = add i24 %x, %y
     ret i24 %z
 }
 
 ; CHECK-LABEL: return_zero:
 ; CHECK-NEXT: .functype return_zero () -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 0{{$}}
+; CHECK-NEXT: i32.const  $push0=, 0{{$}}
 ; CHECK-NEXT: end_function
 define i24 @return_zero() {
     ret i24 0
 }

test/CodeGen/WebAssembly/function-bitcasts-varargs.ll

entry:
   call void(...) bitcast (void (i32, i32)* @specified to void (...)*)(i32 0, i32 1)
   ret void
 }
 
 declare void @underspecified(...)
 declare void @specified(i32, i32)
 
 ; CHECK: callWithArgs:
-; CHECK: i32.const  $push1=, 0
-; CHECK-NEXT: i32.const $push0=, 1
-; CHECK-NEXT: call      .Lunderspecified_bitcast, $pop1, $pop0
-; CHECK: call     .Lspecified_bitcast, $pop{{[0-9]+$}}
+; CHECK: i32.const  $push1=, 0
+; CHECK-NEXT: i32.const  $push0=, 1
+; CHECK-NEXT: call      .Lunderspecified_bitcast, $pop1, $pop0
+; CHECK: call      .Lspecified_bitcast, $pop{{[0-9]+$}}
 
 ; CHECK: .Lunderspecified_bitcast:
 ; CHECK-NEXT: .functype .Lunderspecified_bitcast (i32, i32) -> (){{$}}
-; CHECK: call     underspecified, $pop{{[0-9]+$}}
+; CHECK: call      underspecified, $pop{{[0-9]+$}}
 
 ; CHECK: .Lspecified_bitcast:
 ; CHECK-NEXT: .functype .Lspecified_bitcast (i32) -> (){{$}}
-; CHECK: call     specified, $pop{{[0-9]+}}, $pop{{[0-9]+$}}
+; CHECK: call      specified, $pop{{[0-9]+}}, $pop{{[0-9]+$}}

test/CodeGen/WebAssembly/inline-asm-roundtrip.ll

 ;        : "r" (src));
 ;   return dst != 3;
 ; }
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; CHECK-LABEL: main:
-; CHECK-NEXT: .functype main (i32, i32) -> (i32)
-; CHECK-NEXT: .local    i32
-; CHECK-NEXT: i32.const 1
-; CHECK-NEXT: local.set [[SRC:[0-9]+]]
-; CHECK-NEXT: i32.const 2
-; CHECK-NEXT: local.get [[SRC]]
-; CHECK-NEXT: i32.add
-; CHECK-NEXT: local.set [[DST:[0-9]+]]
-; CHECK-NEXT: local.get [[DST]]
-; CHECK-NEXT: i32.const 3
-; CHECK-NEXT: i32.ne
+; CHECK-NEXT:  .functype main (i32, i32) -> (i32)
+; CHECK-NEXT:  .local    i32
+; CHECK-NEXT:  i32.const  1
+; CHECK-NEXT:  local.set  [[SRC:[0-9]+]]
+; CHECK-NEXT:  i32.const  2
+; CHECK-NEXT:  local.get  [[SRC]]
+; CHECK-NEXT:  i32.add
+; CHECK-NEXT:  local.set  [[DST:[0-9]+]]
+; CHECK-NEXT:  local.get  [[DST]]
+; CHECK-NEXT:  i32.const  3
+; CHECK-NEXT:  i32.ne
 
 define i32 @main(i32 %argc, i8** nocapture readnone %argv) #0 {
 entry:
   %0 = tail call i32 asm "i32.const\092\0A\09local.get\09$1\0A\09i32.add\0A\09local.set\09$0", "=r,r"(i32 1) #1
   %cmp = icmp ne i32 %0, 3
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 

test/CodeGen/WebAssembly/tls.ll

 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck --check-prefix=SINGLE %s
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; SINGLE-LABEL: address_of_tls:
 define i32 @address_of_tls() {
   ; SINGLE: i32.const $push0=, tls
   ; SINGLE-NEXT: return $pop0
   ret i32 ptrtoint(i32* @tls to i32)
 }
 
-; SINGLE: .type tls,@object
-; SINGLE-NEXT: .section .bss.tls,"",@
+; SINGLE: .type  tls,@object
+; SINGLE-NEXT: .section  .bss.tls,"",@
 ; SINGLE-NEXT: .p2align 2
 ; SINGLE-NEXT: tls:
 ; SINGLE-NEXT: .int32 0
 @tls = internal thread_local global i32 0

test/CodeGen/WebAssembly/unsupported-function-bitcasts.ll

 define void @test_invalid_rtn() {
 entry:
   call i32 bitcast (i32 (i64)* @has_i64_arg to i32 (i32)*)(i32 0)
   call [1 x i64] bitcast (i32 (i64)* @has_i64_arg to [1 x i64] (i64)*)(i64 0)
   ret void
 }
 
 ; CHECK-LABEL: test_struct_rtn:
-; CHECK:  call      has_i64_arg, $pop6, $pop0
+; CHECK:   call      has_i64_arg, $pop6, $pop0
 define void @test_struct_rtn() {
   call {i32, i32} bitcast (i32 (i64)* @has_i64_arg to {i32, i32} (i64)*)(i64 0)
   ret void
 }
 
 ; CHECK-LABEL: test_invalid_arg:
-; CHECK:        i32.const $push[[L0:[0-9]+]]=, 2{{$}}
-; CHECK-NEXT:   i32.call  $push[[L1:[0-9]+]]=, .Lhas_ptr_arg_bitcast_invalid.4, $pop[[L0]]{{$}}
-; CHECK-NEXT:   drop  $pop[[L1]]{{$}}
-; CHECK-NEXT:   i32.const $push[[L0:[0-9]+]]=, 2{{$}}
-; CHECK-NEXT:   i32.call  $push[[L1:[0-9]+]]=, has_ptr_arg, $pop[[L0]]{{$}}
-; CHECK-NEXT:   drop  $pop[[L1]]{{$}}
-; CHECK-NEXT:   i64.const $push[[L0:[0-9]+]]=, 3{{$}}
-; CHECK-NEXT:   i32.call  $push[[L1:[0-9]+]]=, .Lhas_ptr_arg_bitcast_invalid, $pop[[L0]]{{$}}
-; CHECK-NEXT:   drop  $pop[[L1]]{{$}}
-; CHECK-NEXT:   end_function
+; CHECK:        i32.const  $push[[L0:[0-9]+]]=, 2{{$}}
+; CHECK-NEXT:   i32.call  $push[[L1:[0-9]+]]=, .Lhas_ptr_arg_bitcast_invalid.4, $pop[[L0]]{{$}}
+; CHECK-NEXT:   drop  $pop[[L1]]{{$}}
+; CHECK-NEXT:   i32.const  $push[[L0:[0-9]+]]=, 2{{$}}
+; CHECK-NEXT:   i32.call  $push[[L1:[0-9]+]]=, has_ptr_arg, $pop[[L0]]{{$}}
+; CHECK-NEXT:   drop  $pop[[L1]]{{$}}
+; CHECK-NEXT:   i64.const  $push[[L0:[0-9]+]]=, 3{{$}}
+; CHECK-NEXT:   i32.call  $push[[L1:[0-9]+]]=, .Lhas_ptr_arg_bitcast_invalid, $pop[[L0]]{{$}}
+; CHECK-NEXT:   drop  $pop[[L1]]{{$}}
+; CHECK-NEXT:   end_function
 define void @test_invalid_arg() {
 entry:
   call i32 bitcast (i32 (i8*)* @has_ptr_arg to i32 (i8)*)(i8 2)
   call i32 bitcast (i32 (i8*)* @has_ptr_arg to i32 (i32)*)(i32 2)
   call i32 bitcast (i32 (i8*)* @has_ptr_arg to i32 (i64)*)(i64 3)
   ret void
 }
 
 ; CHECK-LABEL: .Lhas_i64_arg_bitcast_invalid:
 ; CHECK-NEXT:  .functype .Lhas_i64_arg_bitcast_invalid (i64) -> (i64)
 ; CHECK-NEXT:  unreachable
 ; CHECK-NEXT:  end_function
 
 ; CHECK-LABEL: .Lhas_i64_arg_bitcast_invalid.2:
 ; CHECK-NEXT:  .functype .Lhas_i64_arg_bitcast_invalid.2 (i32) -> (i32)
 ; CHECK-NEXT:  unreachable
 ; CHECK-NEXT:  end_function
 
 ; CHECK-LABEL: .Lhas_ptr_arg_bitcast_invalid:
-; CHECK-NEXT:   .functype .Lhas_ptr_arg_bitcast_invalid (i64) -> (i32)
-; CHECK-NEXT:   unreachable
-; CHECK-NEXT:   end_function
+; CHECK-NEXT:   .functype .Lhas_ptr_arg_bitcast_invalid (i64) -> (i32)
+; CHECK-NEXT:   unreachable
+; CHECK-NEXT:   end_function
 
 ; CHECK-LABEL: .Lhas_ptr_arg_bitcast_invalid.4:
-; CHECK-NEXT:   .functype .Lhas_ptr_arg_bitcast_invalid.4 (i32) -> (i32)
-; CHECK-NEXT:   unreachable
-; CHECK-NEXT:   end_function
+; CHECK-NEXT:   .functype .Lhas_ptr_arg_bitcast_invalid.4 (i32) -> (i32)
+; CHECK-NEXT:   unreachable
+; CHECK-NEXT:   end_function

test/CodeGen/WebAssembly/userstack.ll

 ; CHECK-NEXT:  # %{{[0-9]+}}{{$}}
 ; CHECK-NEXT:  #NO_APP
 define void @inline_asm() {
   %tmp = alloca i8
   call void asm sideeffect "# %0", "r"(i8* %tmp)
   ret void
 }
 
-; CHECK: .globaltype  __stack_pointer, i32{{$}}
+; CHECK: .globaltype  __stack_pointer, i32{{$}}
 
 ; TODO: test over-aligned alloca

test/MC/WebAssembly/assembler-binary.ll

 entry:
   call void @bar()
   ret void
 }
 
 ; Checking assembly is not the point of this test, but if something breaks
 ; it is easier to spot it here than in the yaml output.
 
-; ASM:      .text
-; ASM:        .file "assembler-binary.ll"
-; ASM:        .globl  foo
+; ASM:        .text
+; ASM:        .file  "assembler-binary.ll"
+; ASM:        .globl  foo
 ; ASM:      foo:
-; ASM-NEXT:   .functype foo (i32) -> ()
-; ASM-NEXT:   call  bar
-; ASM-NEXT:   end_function
-; ASM:        .functype bar () -> ()
+; ASM-NEXT:   .functype  foo (i32) -> ()
+; ASM-NEXT:   call  bar
+; ASM-NEXT:   end_function
+; ASM:        .functype  bar () -> ()
 
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:

test/MC/WebAssembly/basic-assembly.s

.LBB0_4:
     end_try
     i32.const .L.str
     throw 0
 .LBB0_5:
     #i32.trunc_sat_f32_s
     global.get  __stack_pointer
     end_function
 
-    .section  .rodata..L.str,"",@
+    .section  .rodata..L.str,"",@
 .L.str:
-    .int8 'H'
-    .asciz  "ello, World!"
-    .size .L.str, 14
+    .int8  'H'
+    .asciz  "ello, World!"
+    .size  .L.str, 14
 
-    .globaltype __stack_pointer, i32
+    .globaltype  __stack_pointer, i32
 
 # CHECK:           .text
 # CHECK-LABEL: test0:
 # CHECK-NEXT:      .functype test0 (i32, i64) -> (i32)
 # CHECK-NEXT:      .eventtype  __cpp_exception i32
 # CHECK-NEXT:      .local      f32, f64
 # CHECK-NEXT:      local.get   2
 # CHECK-NEXT:      local.set   2

 # CHECK-NEXT:      end_block
 # CHECK-NEXT:      end_try
 # CHECK-NEXT:      i32.const .L.str
 # CHECK-NEXT:      throw 0
 # CHECK-NEXT:  .LBB0_5:
 # CHECK-NEXT:      global.get  __stack_pointer
 # CHECK-NEXT:      end_function
 
-# CHECK:      .section  .rodata..L.str,"",@
-# CHECK-NEXT:.L.str:
-# CHECK-NEXT: .int8 72
-# CHECK-NEXT: .asciz  "ello, World!"
+# CHECK:           .section  .rodata..L.str,"",@
+# CHECK-NEXT:  .L.str:
+# CHECK-NEXT:      .int8  72
+# CHECK-NEXT:      .asciz  "ello, World!"
 
-# CHECK:           .globaltype  __stack_pointer, i32
+# CHECK:           .globaltype  __stack_pointer, i32

test/MC/WebAssembly/data-section.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+unimplemented-simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
 # Check that it converts to .o without errors:
 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+unimplemented-simd128,+nontrapping-fptoint,+exception-handling < %s | obj2yaml | FileCheck -check-prefix=BIN %s
 
 # Minimal test for data sections.
 
 test0:
     .functype   test0 () -> (i32)
     i32.const .L.str
 .Ltestlabel:
     end_function
 
-    .section  .rodata..L.str,"",@
+    .section  .rodata..L.str,"",@
 .L.str:
-    .int8 100
-    .size .L.str, 1
+    .int8  100
+    .size  .L.str, 1
 
 
 # CHECK:           .text
 # CHECK-LABEL: test0:
 # CHECK-NEXT:      .functype test0 () -> (i32)
 # CHECK-NEXT:      i32.const .L.str
 # CHECK-NEXT:  .Ltestlabel:
 # CHECK-NEXT:      end_function
 
-# CHECK:      .section  .rodata..L.str,"",@
-# CHECK-NEXT:.L.str:
-# CHECK-NEXT: .int8 100
+# CHECK:           .section  .rodata..L.str,"",@
+# CHECK-NEXT:  .L.str:
+# CHECK-NEXT:      .int8  100
 
 
 # BIN:      --- !WASM
 # BIN-NEXT: FileHeader:
 # BIN-NEXT:   Version:         0x00000001
 # BIN-NEXT: Sections:
 # BIN-NEXT:   - Type:            TYPE
 # BIN-NEXT:     Signatures:

test/MC/WebAssembly/dwarfdump.ll

 ; RUN: llc -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
 
 ; CHECK: .debug_info contents:
 ; CHECK-NEXT: 0x00000000: Compile Unit: length = 0x00000066 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x04 (next unit at 0x0000006a)
 
 ; CHECK: 0x0000000b: DW_TAG_compile_unit
-; CHECK-NEXT:              DW_AT_producer ("clang version 6.0.0 (trunk 315924) (llvm/trunk 315960)")
-; CHECK-NEXT:              DW_AT_language (DW_LANG_C99)
-; CHECK-NEXT:              DW_AT_name ("test.c")
-; CHECK-NEXT:              DW_AT_stmt_list  (0x00000000)
-; CHECK-NEXT:              DW_AT_comp_dir ("/usr/local/google/home/sbc/dev/wasm/simple")
-; CHECK-NEXT:              DW_AT_GNU_pubnames (true)
-; CHECK-NEXT:              DW_AT_low_pc   (0x0000000000000002)
-; CHECK-NEXT:              DW_AT_high_pc    (0x0000000000000004)
+; CHECK-NEXT:              DW_AT_producer  ("clang version 6.0.0 (trunk 315924) (llvm/trunk 315960)")
+; CHECK-NEXT:              DW_AT_language  (DW_LANG_C99)
+; CHECK-NEXT:              DW_AT_name  ("test.c")
+; CHECK-NEXT:              DW_AT_stmt_list  (0x00000000)
+; CHECK-NEXT:              DW_AT_comp_dir  ("/usr/local/google/home/sbc/dev/wasm/simple")
+; CHECK-NEXT:              DW_AT_GNU_pubnames  (true)
+; CHECK-NEXT:              DW_AT_low_pc    (0x0000000000000002)
+; CHECK-NEXT:              DW_AT_high_pc    (0x0000000000000004)
 
 ; CHECK: 0x00000026:   DW_TAG_variable
-; CHECK-NEXT:                DW_AT_name ("foo")
-; CHECK-NEXT:                DW_AT_type (0x00000037 "int*")
-; CHECK-NEXT:                DW_AT_external (true)
-; CHECK-NEXT:                DW_AT_decl_file  ("/usr/local/google/home/sbc/dev/wasm/simple{{[/\\]}}test.c")
-; CHECK-NEXT:                DW_AT_decl_line  (4)
-; CHECK-NEXT:                DW_AT_location (DW_OP_addr 0x0)
+; CHECK-NEXT:                DW_AT_name  ("foo")
+; CHECK-NEXT:                DW_AT_type  (0x00000037 "int*")
+; CHECK-NEXT:                DW_AT_external  (true)
+; CHECK-NEXT:                DW_AT_decl_file  ("/usr/local/google/home/sbc/dev/wasm/simple{{[/\\]}}test.c")
+; CHECK-NEXT:                DW_AT_decl_line  (4)
+; CHECK-NEXT:                DW_AT_location  (DW_OP_addr 0x0)
 
 ; CHECK: 0x00000037:   DW_TAG_pointer_type
-; CHECK-NEXT:                DW_AT_type (0x0000003c "int")
+; CHECK-NEXT:                DW_AT_type  (0x0000003c "int")
 
 ; CHECK: 0x0000003c:   DW_TAG_base_type
-; CHECK-NEXT:                DW_AT_name ("int")
-; CHECK-NEXT:                DW_AT_encoding (DW_ATE_signed)
-; CHECK-NEXT:                DW_AT_byte_size  (0x04)
+; CHECK-NEXT:                DW_AT_name  ("int")
+; CHECK-NEXT:                DW_AT_encoding  (DW_ATE_signed)
+; CHECK-NEXT:                DW_AT_byte_size  (0x04)
 
 ; CHECK: 0x00000043:   DW_TAG_variable
-; CHECK-NEXT:                DW_AT_name ("ptr2")
-; CHECK-NEXT:                DW_AT_type (0x00000054 "void()*")
-; CHECK-NEXT:                DW_AT_external (true)
-; CHECK-NEXT:                DW_AT_decl_file  ("/usr/local/google/home/sbc/dev/wasm/simple{{[/\\]}}test.c")
-; CHECK-NEXT:                DW_AT_decl_line  (5)
-; CHECK-NEXT:                DW_AT_location (DW_OP_addr 0x4)
+; CHECK-NEXT:                DW_AT_name  ("ptr2")
+; CHECK-NEXT:                DW_AT_type  (0x00000054 "void()*")
+; CHECK-NEXT:                DW_AT_external  (true)
+; CHECK-NEXT:                DW_AT_decl_file  ("/usr/local/google/home/sbc/dev/wasm/simple{{[/\\]}}test.c")
+; CHECK-NEXT:                DW_AT_decl_line  (5)
+; CHECK-NEXT:                DW_AT_location  (DW_OP_addr 0x4)
 
 ; CHECK: 0x00000054:   DW_TAG_pointer_type
-; CHECK-NEXT:                DW_AT_type (0x00000059 "void()")
+; CHECK-NEXT:                DW_AT_type  (0x00000059 "void()")
 
 ; CHECK: 0x00000059:   DW_TAG_subroutine_type
-; CHECK-NEXT:                DW_AT_prototyped (true)
+; CHECK-NEXT:                DW_AT_prototyped  (true)
 
 ; CHECK: 0x0000005a:   DW_TAG_subprogram
-; CHECK-NEXT:                DW_AT_low_pc (0x0000000000000002)
-; CHECK-NEXT:                DW_AT_high_pc  (0x0000000000000004)
-; CHECK-NEXT:                DW_AT_name ("f2")
-; CHECK-NEXT:                DW_AT_decl_file  ("/usr/local/google/home/sbc/dev/wasm/simple{{[/\\]}}test.c")
-; CHECK-NEXT:                DW_AT_decl_line  (2)
-; CHECK-NEXT:                DW_AT_prototyped (true)
-; CHECK-NEXT:                DW_AT_external   (true)
+; CHECK-NEXT:                DW_AT_low_pc  (0x0000000000000002)
+; CHECK-NEXT:                DW_AT_high_pc  (0x0000000000000004)
+; CHECK-NEXT:                DW_AT_name  ("f2")
+; CHECK-NEXT:                DW_AT_decl_file  ("/usr/local/google/home/sbc/dev/wasm/simple{{[/\\]}}test.c")
+; CHECK-NEXT:                DW_AT_decl_line  (2)
+; CHECK-NEXT:                DW_AT_prototyped  (true)
+; CHECK-NEXT:                DW_AT_external    (true)
 
 ; CHECK: 0x00000069:   NULL
 
 target triple = "wasm32-unknown-unknown"
 
 source_filename = "test.c"
 
 @myextern = external global i32, align 4

test/MC/WebAssembly/objdump.s

test1:
     local.get   3
     end_function
 
 
 # CHECK-LABEL: CODE:
 # CHECK:             # 2 functions in section.
 # CHECK-LABEL: test0:
 # CHECK-NEXT:        .local  f32, f64, v128, v128
-# CHECK-NEXT:       9:       20 02  local.get 2
+# CHECK-NEXT:       9:       20 02  local.get  2
 # CHECK-NEXT:       b:       0b     end
 # CHECK-LABEL: test1:
 # CHECK-NEXT:        .local  i32, i64, except_ref
-# CHECK-NEXT:      14:       20 03  local.get 3
+# CHECK-NEXT:      14:       20 03  local.get  3
 # CHECK-NEXT:      16:       0b     end

test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .data.alias_address
 ; CHECK-NEXT:         Alignment:       3
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT: ...
 
 ; CHECK-SYMS: SYMBOL TABLE:
-; CHECK-SYMS-NEXT: 00000001 g     F CODE  .hidden foo
-; CHECK-SYMS-NEXT: 00000006 g     F CODE  .hidden call_direct
-; CHECK-SYMS-NEXT: 0000000f g     F CODE  .hidden call_alias
-; CHECK-SYMS-NEXT: 00000001 gw    F CODE  .hidden foo_alias
-; CHECK-SYMS-NEXT: 00000018 g     F CODE  .hidden call_direct_ptr
-; CHECK-SYMS-NEXT: 00000008 g     O DATA  direct_address
-; CHECK-SYMS-NEXT: 0000002b g     F CODE  .hidden call_alias_ptr
-; CHECK-SYMS-NEXT: 00000010 g     O DATA  alias_address
-; CHECK-SYMS-NEXT: 00000000 g     O DATA  bar
-; CHECK-SYMS-NEXT: 00000000 gw    O DATA  .hidden bar_alias
+; CHECK-SYMS-NEXT: 00000001 g     F CODE  .hidden foo
+; CHECK-SYMS-NEXT: 00000006 g     F CODE  .hidden call_direct
+; CHECK-SYMS-NEXT: 0000000f g     F CODE  .hidden call_alias
+; CHECK-SYMS-NEXT: 00000001 gw    F CODE  .hidden foo_alias
+; CHECK-SYMS-NEXT: 00000018 g     F CODE  .hidden call_direct_ptr
+; CHECK-SYMS-NEXT: 00000008 g     O DATA  direct_address
+; CHECK-SYMS-NEXT: 0000002b g     F CODE  .hidden call_alias_ptr
+; CHECK-SYMS-NEXT: 00000010 g     O DATA  alias_address
+; CHECK-SYMS-NEXT: 00000000 g     O DATA  bar
+; CHECK-SYMS-NEXT: 00000000 gw    O DATA  .hidden bar_alias

test/tools/llvm-objdump/WebAssembly/symbol-table.test

 RUN: llvm-objdump -t %p/../Inputs/trivial.obj.wasm | FileCheck %s
 
 CHECK:      SYMBOL TABLE:
-CHECK-NEXT: 00000001 g     F CODE main
-CHECK-NEXT: 00000000 l     O DATA .L.str
-CHECK-NEXT: 00000000 g     F *UND*  puts
-CHECK-NEXT: 00000019 l     F CODE .LSomeOtherFunction_bitcast
-CHECK-NEXT: 00000000 g     F *UND*  SomeOtherFunction
-CHECK-NEXT: 00000010 g     O DATA var
+CHECK-NEXT: 00000001 g     F CODE  main
+CHECK-NEXT: 00000000 l     O DATA  .L.str
+CHECK-NEXT: 00000000 g     F *UND*  puts
+CHECK-NEXT: 00000019 l     F CODE  .LSomeOtherFunction_bitcast
+CHECK-NEXT: 00000000 g     F *UND*  SomeOtherFunction
+CHECK-NEXT: 00000010 g     O DATA  var