[ELF][test] Delete large temporary files and make some temporary files smaller with two text segments

[MaskRay]

Summary

Large files are cumbersome on some filesystems and can more easily trigger ENOSPC.

Some tests use two text sections with output section addresses to test branch ranges.
Use two text segments to prevent LLD from filling the gap and unnecessarily increasing the output size.

[psmith]

Looks good to me. Thanks for cleaning this up, it will be of great help to 32-bit bots.

lld/test/ELF/aarch64-cortex-a53-843419-thunk-range.s

2–6

The other test has

rm -rf %t && split-file %s %t

Just thought I'd mention in case this wasn't deliberate.

[MaskRay]

Delete temporarily files larger than 100MiB early.

lld/test/ELF/aarch64-cortex-a53-843419-large.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux %s -o %t.o
 // RUN: ld.lld --fix-cortex-a53-843419 -z separate-code %t.o -o %t2
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=2162688   --stop-address=2162700   | FileCheck --check-prefix=CHECK1 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=2166784   --stop-address=2166788   | FileCheck --check-prefix=CHECK2 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=2170872   --stop-address=2170888   | FileCheck --check-prefix=CHECK3 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=69287928  --stop-address=69287944  | FileCheck --check-prefix=CHECK4 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=102842376 --stop-address=102842392 | FileCheck --check-prefix=CHECK5 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=136384524 --stop-address=136384528 | FileCheck --check-prefix=CHECK6 %s
 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 --start-address=136388604 --stop-address=136388628 | FileCheck --check-prefix=CHECK7 %s
+// RUN: rm %t.o %t2
 // Test case for Cortex-A53 Erratum 843419 in an OutputSection exceeding
 // the maximum branch range. Both range extension thunks and patches are
 // required.                
                   
 // CHECK1:  <__AArch64AbsLongThunk_need_thunk_after_patch>:
 // CHECK1-NEXT:    210000:       50 00 00 58     ldr     x16, 0x210008
 // CHECK1-NEXT:    210004:       00 02 1f d6     br      x16
 // CHECK1: <$d>:

lld/test/ELF/aarch64-cortex-a53-843419-large2.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux %s -o %t.o
 // RUN: ld.lld --fix-cortex-a53-843419 -Ttext=0x8000000 %t.o -o %t2
 // RUN: llvm-objdump -d --start-address=0x8001000 --stop-address=0x8001004 %t2 | FileCheck %s
+/// The temporary files are more than 128MiB. Delete them early.
+// RUN: rm %t.o %t2
 
 .section .text.01, "ax", %progbits
 .balign 4096
 .space 4096 - 8
 adrp x0, thunk
 ldr x1, [x1, #0]
 // CHECK: <thunk>:
 // CHECK-NEXT: b 0xc001008 <__CortexA53843419_8001000>
 thunk:
 ldr x0, [x0, :got_lo12:thunk]
 ret
 .space 64 * 1024 * 1024
 
 .section .text.02, "ax", %progbits
 .space 64 * 1024 * 1024

lld/test/ELF/aarch64-cortex-a53-843419-thunk-range.s

 // REQUIRES: aarch64
-// RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux --asm-macro-max-nesting-depth=40000 %s -o %t.o
-// RUN: echo "SECTIONS { \
-// RUN:          .text1 0x10000 : { *(.text.*) } \
-// RUN:          .text2 0xf010000 : { *(.target) } } " > %t.script
-// RUN: ld.lld --script %t.script -fix-cortex-a53-843419 %t.o -o %t2 --print-map 2>&1 | FileCheck %s
+// RUN: split-file %s %t
+// RUN: llvm-mc -filetype=obj -triple=aarch64 --asm-macro-max-nesting-depth=40000 %t/asm -o %t.o
+// RUN: ld.lld -T %t/lds -fix-cortex-a53-843419 %t.o -o %t2 --print-map 2>&1 | FileCheck %s
+/// %t2 is more than 128MiB. Delete it early.
+// RUN: rm %t.o %t2
 
+//--- asm
 /// We use %(\parameter) to evaluate expression, which requires .altmacro.
  .altmacro
 
 /// Test to reproduce the conditions that trigger R_AARCH64_JUMP26 out of range
 /// errors in pr44071. We create a large number of patches and thunks, with an
 /// LLD with the fault, the patches will be inserted after the thunks and due
 /// to the size of the thunk section some of the patches go out of range.
 /// With a fixed LLD the patches are inserted before the thunks.

  /// Define the thunk targets
  .section .target, "ax", %progbits
  DEFS 0, 20000
 
  .data
  .global dat1
 dat1:
  .xword 0
+
+//--- lds
+PHDRS {
+  low PT_LOAD FLAGS(0x1 | 0x4);
+  high PT_LOAD FLAGS(0x1 | 0x4);
+}
+SECTIONS {
+  .text1 0x10000 : { *(.text.*) } :low
+  .text2 0xf010000 : { *(.target) } :high
+}

lld/test/ELF/aarch64-thunk-pi.s

 // REQUIRES: aarch64
-// RUN: llvm-mc -filetype=obj -triple=aarch64 %s -o %t.o
-// RUN: echo "SECTIONS { \
-// RUN:       .text_low : { *(.text_low) } \
-// RUN:       .text_high 0x10000000 : { *(.text_high) } \
-// RUN:       } " > %t.script
-// RUN: ld.lld --script %t.script --shared %t.o -o %t.so 2>&1
+// RUN: split-file %s %t
+// RUN: llvm-mc -filetype=obj -triple=aarch64 %t/asm -o %t.o
+// RUN: ld.lld --script %t/lds --shared %t.o -o %t.so 2>&1
 // RUN: llvm-objdump -d --no-show-raw-insn --print-imm-hex %t.so | FileCheck %s
 
 // Check that Position Independent thunks are generated for shared libraries.
+
+//--- asm
  .section .text_low, "ax", %progbits
  .globl low_target
  .type low_target, %function
 low_target:
  // Need thunk to high_target@plt
  bl high_target
  ret
 // CHECK: <low_target>:

 // CHECK-NEXT:                 add     x16, x16, #0x128
 // CHECK-NEXT:                 br      x17
 // CHECK-EMPTY:
 // CHECK-NEXT:   <low_target@plt>:
 // CHECK-NEXT: 10000050:       adrp    x16, #0x0
 // CHECK-NEXT:                 ldr     x17, [x16, #0x130]
 // CHECK-NEXT:                 add     x16, x16, #0x130
 // CHECK-NEXT:                 br      x17
+
+//--- lds
+PHDRS {
+  low PT_LOAD FLAGS(0x1 | 0x4);
+  high PT_LOAD FLAGS(0x1 | 0x4);
+}
+SECTIONS {
+  .text_low : { *(.text_low) } :low
+  .text_high 0x10000000 : { *(.text_high) } :high
+}

lld/test/ELF/aarch64-thunk-script.s

 // REQUIRES: aarch64
-// RUN: llvm-mc -filetype=obj -triple=aarch64 %s -o %t.o
-// RUN: echo "SECTIONS { \
-// RUN:       .text_low 0x2000: { *(.text_low) } \
-// RUN:       .text_high 0x8002000 : { *(.text_high) } \
-// RUN:       } " > %t.script
-// RUN: ld.lld --script %t.script %t.o -o %t
-// RUN: llvm-objdump -d --no-show-raw-insn --print-imm-hex %t | FileCheck %s
-// RUN: llvm-nm --no-sort --special-syms %t | FileCheck --check-prefix=NM %s
+// RUN: split-file %s %t
+// RUN: llvm-mc -filetype=obj -triple=aarch64 %t/asm -o %t.o
+// RUN: ld.lld --script %t/lds %t.o -o %t/out
+// RUN: llvm-objdump -d --no-show-raw-insn --print-imm-hex %t/out | FileCheck %s
+// RUN: llvm-nm --no-sort --special-syms %t/out | FileCheck --check-prefix=NM %s
 
+//--- asm
 // Check that we have the out of branch range calculation right. The immediate
 // field is signed so we have a slightly higher negative displacement.
  .section .text_low, "ax", %progbits
  .globl _start
  .type _start, %function
 _start:
  // Need thunk to high_target@plt
  bl high_target

 // NM-NEXT: t $x
 // NM-NEXT: t $d
 // NM-NEXT: t __AArch64AbsLongThunk_{{$}}
 // NM-NEXT: t $x
 // NM-NEXT: t $d
 /// Global symbols.
 // NM-NEXT: T _start
 // NM-NEXT: T high_target
+
+//--- lds
+PHDRS {
+  low PT_LOAD FLAGS(0x1 | 0x4);
+  high PT_LOAD FLAGS(0x1 | 0x4);
+}
+SECTIONS {
+  .text_low 0x2000: { *(.text_low) } :low
+  .text_high 0x8002000 : { *(.text_high) } :high
+}

lld/test/ELF/aarch64-thunk-section-location.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-linux-gnu %s -o %t.o
 // RUN: ld.lld %t.o -o %t
 // RUN: llvm-objdump -d --start-address=0x81d1008 --stop-address=0x81d1014 --no-show-raw-insn %t | FileCheck %s
+// RUN: rm %t.o %t
 // Check that the range extension thunks are dumped close to the aarch64 branch
 // range of 128 MiB
  .section .text.1, "ax", %progbits
  .balign 0x1000
  .globl _start
 _start:
  bl high_target
  ret

lld/test/ELF/arm-thumb-plt-range-thunk-os.s

 // REQUIRES: arm
 // RUN: llvm-mc -arm-add-build-attributes -filetype=obj -triple=thumbv7a-none-linux-gnueabi %s -o %t
 // RUN: ld.lld %t --shared --icf=all -o %t.so
 // The output file is large, most of it zeroes. We dissassemble only the
 // parts we need to speed up the test and avoid a large output file
 // RUN: llvm-objdump -d %t.so --start-address=0x2000000 --stop-address=0x2000018 --triple=thumbv7a-linux-gnueabihf | FileCheck --check-prefix=CHECK1 %s
 // RUN: llvm-objdump -d %t.so --start-address=0x2800004 --stop-address=0x2800034 --triple=thumbv7a-linux-gnueabihf | FileCheck --check-prefix=CHECK2 %s
 // RUN: llvm-objdump -d %t.so --start-address=0x4000000 --stop-address=0x4000010 --triple=thumbv7a-linux-gnueabihf | FileCheck --check-prefix=CHECK3 %s
 // RUN: llvm-objdump -d %t.so --start-address=0x4000010 --stop-address=0x4000100 --triple=armv7a-linux-gnueabihf | FileCheck --check-prefix=CHECK4 %s
+// RUN: rm %t.so
  .syntax unified
  .thumb
 
 // Make sure that we generate a range extension thunk to a PLT entry
  .section ".text.1", "ax", %progbits
  .global sym1
  .global elsewhere
  .type elsewhere, %function