[JITLink][ELF] Omit temporary labels in tests

[sgraenitz]

Summary

Oneshot temporary labels for declaring function size can be omitted. Follow-up from D90331.

[MaskRay]

Thanks!

llvm/test/ExecutionEngine/JITLink/X86/ELF_x86-64_common.s

 load_common:
 # Check that common variable GOT entry is synthesized correctly. In order to
 # prevent the optimizer from relaxing the edge, we use a movl instruction.
 # jitlink-check: decode_operand(load_common, 4) = \
 # jitlink-check:   got_addr(elf_common.o, common_data) - next_pc(load_common)
 # jitlink-check: *{8}(got_addr(elf_common.o, common_data)) = common_data
         movl    common_data@GOTPCREL(%rip), %eax
         ret
-.Lfunc_end0:
-        .size   load_common, .Lfunc_end0-load_common
+
+        .size   load_common, .-load_common
 
 # Check that common is zero-filled.
 # jitlink-check: *{4}(common_data) = 0
         .type   common_data,@object
         .comm   common_data,4,4

llvm/test/ExecutionEngine/JITLink/X86/ELF_x86-64_relocations.s

# Test standard ELF relocations.
         .file   "testcase.c"
 
 # Empty main entry point.
         .globl  main
         .p2align        4, 0x90
         .type   main,@function
 main:
         retq
-.Lfunc_end0:
-        .size   main, .Lfunc_end0-main
+
+        .size   main, .-main
 
 # Test PCRel32 / R_X86_64_PC32 handling.
 # jitlink-check: decode_operand(test_pcrel32, 4) = named_data - next_pc(test_pcrel32)
         .globl  test_pcrel32
         .p2align       4, 0x90
         .type   test_pcrel32,@function
 test_pcrel32:
         movl    named_data(%rip), %eax
-.Lend_test_pcrel32:
-         .size   test_pcrel32, .Lend_test_pcrel32-test_pcrel32
+
+         .size   test_pcrel32, .-test_pcrel32
 
         .globl  named_func
         .p2align       4, 0x90
         .type   named_func,@function
 named_func:
         xorq    %rax, %rax
-.Lend_named_func:
-        .size   named_func, .Lend_named_func-named_func
+
+        .size   named_func, .-named_func
 
 # Check R_X86_64_PLT32 handling with a call to a local function. This produces a
 # Branch32 edge that is resolved like a regular PCRel32 (no PLT entry created).
 #
 # jitlink-check: decode_operand(test_call_local, 0) = named_func - next_pc(test_call_local)
         .globl  test_call_local
         .p2align       4, 0x90
         .type   test_call_local,@function
 test_call_local:
         callq   named_func
-.Lend_test_call_local:
-        .size   test_call_local, .Lend_test_call_local-test_call_local
+
+        .size   test_call_local, .-test_call_local
 
 # Check R_X86_64_PLT32 handling with a call to an external. This produces a
 # Branch32ToStub edge, because externals are not defined locally. During
 # resolution, the target turns out to be in-range from the callsite and so the
 # edge is relaxed in post-allocation optimization.
 #
 # jitlink-check: decode_operand(test_call_extern, 0) = extern_in_range32 - next_pc(test_call_extern)
         .globl  test_call_extern
         .p2align       4, 0x90
         .type   test_call_extern,@function
 test_call_extern:
         callq   extern_in_range32@plt
-.Lend_test_call_extern:
-        .size   test_call_extern, .Lend_test_call_extern-test_call_extern
+
+        .size   test_call_extern, .-test_call_extern
 
 # Check R_X86_64_PLT32 handling with a call to an external via PLT. This
 # produces a Branch32ToStub edge, because externals are not defined locally.
 # As the target is out-of-range from the callsite, the edge keeps using its PLT
 # entry.
 #
 # jitlink-check: decode_operand(test_call_extern_plt, 0) = \
 # jitlink-check:     stub_addr(elf_reloc.o, extern_out_of_range32) - next_pc(test_call_extern_plt)
 # jitlink-check: *{8}(got_addr(elf_reloc.o, extern_out_of_range32)) = extern_out_of_range32
         .globl  test_call_extern_plt
         .p2align       4, 0x90
         .type   test_call_extern_plt,@function
 test_call_extern_plt:
         callq   extern_out_of_range32@plt
-.Lend_test_call_extern_plt:
-        .size   test_call_extern_plt, .Lend_test_call_extern_plt-test_call_extern_plt
+
+        .size   test_call_extern_plt, .-test_call_extern_plt
 
 # Test GOTPCREL handling. We want to check both the offset to the GOT entry and its
 # contents.
 # jitlink-check: decode_operand(test_gotpcrel, 4) = got_addr(elf_reloc.o, named_data) - next_pc(test_gotpcrel)
 # jitlink-check: *{8}(got_addr(elf_reloc.o, named_data)) = named_data
 
         .globl test_gotpcrel
         .p2align      4, 0x90
         .type   test_gotpcrel,@function
 test_gotpcrel:
   movl    named_data@GOTPCREL(%rip), %eax
-.Lend_test_gotpcrel:
-        .size   test_gotpcrel, .Lend_test_gotpcrel-test_gotpcrel
+
+        .size   test_gotpcrel, .-test_gotpcrel
 
 # Test REX_GOTPCRELX handling. We want to check both the offset to the GOT entry and its
 # contents.
 # jitlink-check: decode_operand(test_rex_gotpcrelx, 4) = \
 # jitlink-check:   got_addr(elf_reloc.o, external_data) - next_pc(test_rex_gotpcrelx)
 
         .globl test_rex_gotpcrelx
         .p2align      4, 0x90
         .type   test_rex_gotpcrelx,@function
 test_rex_gotpcrelx:
   movq    external_data@GOTPCREL(%rip), %rax
-.Lend_test_rex_gotpcrelx:
-        .size   test_rex_gotpcrelx, .Lend_test_rex_gotpcrelx-test_rex_gotpcrelx
+
+        .size   test_rex_gotpcrelx, .-test_rex_gotpcrelx
 
         .type   named_data,@object
         .data
         .p2align        3
 named_data:
         .quad   42
         .size   named_data, 8