[CallSiteInfo] Fix the assertions regarding updating the CallSiteInfo

[djtodoro]

Summary

The call site info was not updated correctly when deleting corresponding call instructions.

(this was split from the D73534)

[vsk]

llvm/lib/CodeGen/MachineLICM.cpp

1373

I'm a bit confused by this one. ExtractHoistableLoad can hoist a call? What cases MI->isDereferenceableInvariantLoad(AA) and MI->isCall() to both be true?

llvm/lib/CodeGen/TargetLoweringBase.cpp

1074

Should PATCHPOINT/STATEPOINT/STACKMAP instructions ever be assigned call site info in the first place? It seems like these should not even get call site entries.

Maybe we could add a helper, like MachineInstr::isCandidateForCallSiteEntry(), that we can check before calling addCallArgsForwardingRegs.

1095

Ditto for PATCHABLE_EVENT_CALL, seems risky to emit call site info for this.

1115

Ditto for PATCHABLE_TYPED_EVENT_CALL.

llvm/test/CodeGen/AArch64/arm64-anyregcc.ll

3

It seems like the FileCheck commands added to these tests can just be removed, as they aren't strictly checking the 'callSites' info in the yaml. Without the FileCheck invocation, the test will still assert if assertions are enabled.

[djtodoro]

@vsk Thanks for the comments!

llvm/lib/CodeGen/TargetLoweringBase.cpp

1074

Maybe we could add a helper, like MachineInstr::isCandidateForCallSiteEntry(), that we can check before calling addCallArgsForwardingRegs.

We have an assertion within the addCallArgsForwardingRegs() checking the call site info is created only for the calls, but it turns out we have calls we do not want to handle here...

I agree, the MachineInstr::isCandidateForCallSiteEntry() is great idea to get this things into the good shape!
I will work on adding that!

llvm/test/CodeGen/AArch64/arm64-anyregcc.ll

3

I thought removing them in the next patch from the stack. These should just show the places where the assertions have occurred.

[djtodoro]

llvm/lib/CodeGen/MachineLICM.cpp

1373

I was surprised as well.

The case I found this:
CALL64m $rip, 1, $noreg, target-flags(x86-gotpcrel) @objc_msgSend, $noreg, <regmask $bh $bl $bp $bph $bpl $bx $ebp $ebx $hbp $hbx $rbp $rbx $r12 $r13 $r14 $r15 $r12b $r13b $r14b $r15b $r12bh $r13bh $r14bh $r15bh $r12d $r13d $r14d $r15d $r12w $r13w $r14w $r15w $r12wh and 3 more...>, implicit $rsp, implicit $ssp, implicit $rdi, implicit $rsi, implicit-def $rsp, implicit-def $ssp, implicit-def $rax :: (load 8 from got)

from the llvm/test/CodeGen/X86/hoist-invariant-load.ll

[djtodoro]

-Using the isCandidateForCallSiteEntry()

[vsk]

LGTM, pending resolution of https://reviews.llvm.org/D74121 vs. https://reviews.llvm.org/D74159. (I believe this can easily be rebased on top of either patch.)

[djtodoro]

-Rebase

llvm/lib/CodeGen/MachineLICM.cpp

if (!IsLoopInvariantInst(*NewMIs[0]) || !IsProfitableToHoist(*NewMIs[0])) {
     NewMIs[1]->eraseFromParent();
     return nullptr;
   }
 
   // Update register pressure for the unfolded instruction.
   UpdateRegPressure(NewMIs[1]);
 
   // Otherwise we successfully unfolded a load that we can hoist.
+
+  // Update the call site info.
+  if (MI->isCall())
+    MF.eraseCallSiteInfo(MI);
+
   MI->eraseFromParent();
   return NewMIs[0];
 }
 
 /// Initialize the CSE map with instructions that are in the current loop
 /// preheader that may become duplicates of instructions that are hoisted
 /// out of the loop.
 void MachineLICMBase::InitCSEMap(MachineBasicBlock *BB) {

llvm/lib/CodeGen/TargetLoweringBase.cpp

if (MI->getOpcode() != TargetOpcode::STATEPOINT) {
           MachinePointerInfo::getFixedStack(MF, FI), Flags,
           MF.getDataLayout().getPointerSize(), MFI.getObjectAlignment(FI));
       MIB->addMemOperand(MF, MMO);
     }
     
     // Replace the instruction and update the operand index.
     MBB->insert(MachineBasicBlock::iterator(MI), MIB);
     OperIdx += (MIB->getNumOperands() - MI->getNumOperands()) - 1;
+
+    // Update the call site info.
+    if (MI->isCall())
+      MI->getMF()->moveCallSiteInfo(MI, &*MIB);
     MI->eraseFromParent();
     MI = MIB;
   }
   return MBB;
 }
 
 MachineBasicBlock *
 TargetLoweringBase::emitXRayCustomEvent(MachineInstr &MI,
                                         MachineBasicBlock *MBB) const {
   assert(MI.getOpcode() == TargetOpcode::PATCHABLE_EVENT_CALL &&
          "Called emitXRayCustomEvent on the wrong MI!");
   auto &MF = *MI.getMF();
   auto MIB = BuildMI(MF, MI.getDebugLoc(), MI.getDesc());
   for (unsigned OpIdx = 0; OpIdx != MI.getNumOperands(); ++OpIdx)
     MIB.add(MI.getOperand(OpIdx));
 
   MBB->insert(MachineBasicBlock::iterator(MI), MIB);
+
+  // Update the call site info.
+  if (MI.isCall())
+    MI.getMF()->moveCallSiteInfo(&MI, &*MIB);
   MI.eraseFromParent();
+
   return MBB;
 }
 
 MachineBasicBlock *
 TargetLoweringBase::emitXRayTypedEvent(MachineInstr &MI,
                                        MachineBasicBlock *MBB) const {
   assert(MI.getOpcode() == TargetOpcode::PATCHABLE_TYPED_EVENT_CALL &&
          "Called emitXRayTypedEvent on the wrong MI!");
   auto &MF = *MI.getMF();
   auto MIB = BuildMI(MF, MI.getDebugLoc(), MI.getDesc());
   for (unsigned OpIdx = 0; OpIdx != MI.getNumOperands(); ++OpIdx)
     MIB.add(MI.getOperand(OpIdx));
 
   MBB->insert(MachineBasicBlock::iterator(MI), MIB);
+
+  // Update the call site info.
+  if (MI.isCall())
+    MI.getMF()->moveCallSiteInfo(&MI, &*MIB);
+
   MI.eraseFromParent();
+
   return MBB;
 }
 
 /// findRepresentativeClass - Return the largest legal super-reg register class
 /// of the register class for the specified type and its associated "cost".
 // This function is in TargetLowering because it uses RegClassForVT which would
 // need to be moved to TargetRegisterInfo and would necessitate moving
 // isTypeLegal over as well - a massive change that would just require

llvm/lib/Target/AArch64/AArch64CleanupLocalDynamicTLSPass.cpp

MachineInstr *replaceTLSBaseAddrCall(MachineInstr &I,
     const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
 
     // Insert a Copy from TLSBaseAddrReg to x0, which is where the rest of the
     // code sequence assumes the address will be.
     MachineInstr *Copy = BuildMI(*I.getParent(), I, I.getDebugLoc(),
                                  TII->get(TargetOpcode::COPY), AArch64::X0)
                              .addReg(TLSBaseAddrReg);
 
+    // Update the call site info.
+    if (I.isCall())
+      I.getMF()->eraseCallSiteInfo(&I);
+
     // Erase the TLS_base_addr instruction.
     I.eraseFromParent();
 
     return Copy;
   }
 
   // Create a virtual register in *TLSBaseAddrReg, and populate it by
   // inserting a copy instruction after I. Returns the new instruction.

llvm/lib/Target/X86/X86SpeculativeLoadHardening.cpp

for (auto MII = MBB.instr_begin(), MIE = MBB.instr_end(); MII != MIE;) {
             TII->unfoldMemoryOperand(MF, MI, Reg, /*UnfoldLoad*/ true,
                                      /*UnfoldStore*/ false, NewMIs);
         (void)Unfolded;
         assert(Unfolded &&
                "Computed unfolded register class but failed to unfold");
         // Now stitch the new instructions into place and erase the old one.
         for (auto *NewMI : NewMIs)
           MBB.insert(MI.getIterator(), NewMI);
+
+        // Update the call site info.
+        if (MI.isCall())
+          MF.eraseCallSiteInfo(&MI);
+
         MI.eraseFromParent();
         LLVM_DEBUG({
           dbgs() << "Unfolded load successfully into:\n";
           for (auto *NewMI : NewMIs) {
             NewMI->dump();
             dbgs() << "\n";
           }
         });

llvm/test/CodeGen/AArch64/arm64-anyregcc.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=arm64-apple-darwin -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc < %s -mtriple=arm64-apple-darwin | FileCheck %s
 
 ; Stackmap Header: no constants - 6 callsites
 ; CHECK-LABEL: .section __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
 ; CHECK-NEXT:   .byte 3
 ; CHECK-NEXT:   .byte 0

llvm/test/CodeGen/AArch64/arm64-patchpoint.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=arm64-apple-darwin -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -mtriple=arm64-apple-darwin -enable-misched=0 -mcpu=cyclone                             < %s | FileCheck %s
 ; RUN: llc -mtriple=arm64-apple-darwin -enable-misched=0 -mcpu=cyclone -fast-isel -fast-isel-abort=1 < %s | FileCheck %s
 
 ; Trivial patchpoint codegen
 ;
 define i64 @trivial_patchpoint_codegen(i64 %p1, i64 %p2, i64 %p3, i64 %p4) {
 entry:
 ; CHECK-LABEL: trivial_patchpoint_codegen:

llvm/test/CodeGen/AArch64/arm64-tls-dynamics.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=arm64-none-linux-gnu -stop-after=machineverifier -relocation-model=pic -aarch64-elf-ldtls-generation=1 < %s | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -mtriple=arm64-none-linux-gnu -relocation-model=pic -aarch64-elf-ldtls-generation=1 -verify-machineinstrs < %s | FileCheck %s
 ; RUN: llc -mtriple=arm64-none-linux-gnu -relocation-model=pic -aarch64-elf-ldtls-generation=1 -filetype=obj < %s | llvm-objdump -r - | FileCheck --check-prefix=CHECK-RELOC %s
 ; RUN: llc -mtriple=arm64-none-linux-gnu -relocation-model=pic -verify-machineinstrs < %s | FileCheck --check-prefix=CHECK-NOLD %s
 ; RUN: llc -mtriple=arm64-none-linux-gnu -relocation-model=pic -filetype=obj < %s | llvm-objdump -r - | FileCheck --check-prefix=CHECK-NOLD-RELOC %s
 ; FIXME: We currently produce "small" code for the tiny model
 ; RUN: llc -mtriple=arm64-none-linux-gnu -relocation-model=pic -aarch64-elf-ldtls-generation=1 -code-model=tiny -verify-machineinstrs < %s | FileCheck %s
 ; FIXME: We currently error for the large code model
 ; RUN: not llc -mtriple=arm64-none-linux-gnu -relocation-model=pic -aarch64-elf-ldtls-generation=1 -code-model=large -verify-machineinstrs < %s 2>&1 | FileCheck %s --check-prefix=CHECK-LARGE

llvm/test/CodeGen/AArch64/stackmap-frame-setup.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc -o - -debug-entry-values -mtriple=aarch64-apple-darwin -stop-after machine-sink %s | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -o - -verify-machineinstrs -mtriple=aarch64-apple-darwin -stop-after machine-sink %s | FileCheck %s --check-prefix=ISEL
 ; RUN: llc -o - -verify-machineinstrs -mtriple=aarch64-apple-darwin -fast-isel -fast-isel-abort=1 -stop-after machine-sink %s | FileCheck %s --check-prefix=FAST-ISEL
 
 define void @caller_meta_leaf() {
 entry:
   %metadata = alloca i64, i32 3, align 8
   store i64 11, i64* %metadata
   store i64 12, i64* %metadata

llvm/test/CodeGen/AArch64/stackmap.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=arm64-linux-gnu -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc < %s -mtriple=arm64-linux-gnu | FileCheck %s
 ;
 ; Note: Print verbose stackmaps using -debug-only=stackmaps.
 
 ; CHECK-LABEL:  .section  .llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
 ; CHECK-NEXT:   .byte 3

llvm/test/CodeGen/X86/anyregcc.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=x86_64-apple-darwin -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin                  -frame-pointer=all | FileCheck %s
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7     -frame-pointer=all | FileCheck --check-prefix=SSE %s
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7-avx -frame-pointer=all | FileCheck --check-prefix=AVX %s
 
 
 ; Stackmap Header: no constants - 6 callsites
 ; CHECK-LABEL:  .section __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:   __LLVM_StackMaps:

llvm/test/CodeGen/X86/combineIncDecVector-crash.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc < %s | FileCheck %s
 
 ; This used to crash, just ensure that it doesn't.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @TestvMeth(i32 %0, i64 %1) gc "statepoint-example" !prof !1 {

llvm/test/CodeGen/X86/deopt-bundles.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc     < %s | FileCheck %s
 ; RUN: llc -O3 < %s | FileCheck %s
 ; RUN: llc -O3 -debug-only=stackmaps < %s 2>&1 | FileCheck -check-prefix=STACKMAPS %s
 ; REQUIRES: asserts
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 

llvm/test/CodeGen/X86/fast-isel-gc-intrinsics.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc < %s -fast-isel
 
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 ; Dont crash with gc intrinsics.
 
 ; gcrelocate call should not be an LLVM Machine Block by itself.
 define i8 addrspace(1)* @test_gcrelocate(i8 addrspace(1)* %v) gc "statepoint-example" {

llvm/test/CodeGen/X86/hoist-invariant-load.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; REQUIRES: asserts
 ; RUN: llc -mcpu=haswell < %s -O2 2>&1 | FileCheck %s
 ; For test:
 ; 2 invariant loads, 1 for OBJC_SELECTOR_REFERENCES_
 ; and 1 for objc_msgSend from the GOT
 ; For test_multi_def:
 ; 2 invariant load (full multiply, both loads should be hoisted.)
 ; For test_div_def:

llvm/test/CodeGen/X86/machine-sink-and-implicit-null-checks.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=x86_64-apple-macosx -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -mtriple=x86_64-apple-macosx -O3 -enable-implicit-null-checks -o - < %s 2>&1 | FileCheck %s
 
 declare void @throw0()
 declare void @throw1()
 
 define i1 @f(i8* %p0, i8* %p1) {
  entry:
   %c0 = icmp eq i8* %p0, null

llvm/test/CodeGen/X86/patchpoint.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=x86_64-apple-darwin -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -mtriple=x86_64-apple-darwin -mcpu=corei7                             < %s | FileCheck %s
 ; RUN: llc -mtriple=x86_64-apple-darwin -mcpu=corei7 -fast-isel -fast-isel-abort=1 < %s | FileCheck %s
 
 ; Trivial patchpoint codegen
 ;
 define i64 @trivial_patchpoint_codegen(i64 %p1, i64 %p2, i64 %p3, i64 %p4) {
 entry:
 ; CHECK-LABEL: trivial_patchpoint_codegen:

llvm/test/CodeGen/X86/pr33010.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=x86_64-linux-generic -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -mtriple=x86_64-linux-generic < %s | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; We can't create a select of two TargetFrameIndices since the rest
 ; of the backend doesn't know how to handle such a construct.
 define i32 addrspace(1)* @test(i32 addrspace(1)* %a, i32 addrspace(1)* %b, i1 %which) gc "statepoint-example" {
 ; CHECK-LABEL: test:

llvm/test/CodeGen/X86/speculative-load-hardening-indirect.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=x86_64-unknown-linux-gnu -x86-speculative-load-hardening -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -x86-speculative-load-hardening -data-sections | FileCheck %s --check-prefix=X64
 ; FIXME: Fix machine verifier issues and remove -verify-machineinstrs=0. PR39451.
 ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -x86-speculative-load-hardening -relocation-model pic -data-sections -verify-machineinstrs=0 | FileCheck %s --check-prefix=X64-PIC
 ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -x86-speculative-load-hardening -data-sections -mattr=+retpoline | FileCheck %s --check-prefix=X64-RETPOLINE
 ;
 ; FIXME: Add support for 32-bit.
 
 @global_fnptr = external global i32 ()*

llvm/test/CodeGen/X86/stackmap-fast-isel.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=x86_64-apple-darwin -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7                             | FileCheck %s
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7 -fast-isel -fast-isel-abort=1 | FileCheck %s
 
 ; CHECK-LABEL:  .section  __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
 ; CHECK-NEXT:   .byte 3
 ; CHECK-NEXT:   .byte 0

llvm/test/CodeGen/X86/stackmap-frame-setup.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=x86_64-apple-darwin -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -o - -verify-machineinstrs -mtriple=x86_64-apple-darwin -mcpu=corei7 -stop-after machine-sink %s | FileCheck %s --check-prefix=ISEL
 ; RUN: llc -o - -verify-machineinstrs -mtriple=x86_64-apple-darwin -mcpu=corei7 -fast-isel -fast-isel-abort=1 -stop-after machine-sink %s | FileCheck %s --check-prefix=FAST-ISEL
 
 define void @caller_meta_leaf() {
 entry:
   %metadata = alloca i64, i32 3, align 8
   store i64 11, i64* %metadata
   store i64 12, i64* %metadata

llvm/test/CodeGen/X86/stackmap-large-location-size.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple="x86_64-pc-linux-gnu" -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc < %s -mtriple="x86_64-pc-linux-gnu" | FileCheck %s
 
 declare void @callee()
 
 define void @f_0(<1024 x i64> %val) {
 ; CHECK:      .quad 2882400015
 ; CHECK-NEXT: .long .Ltmp0-f_0
 ; CHECK-NEXT: .short  0

llvm/test/CodeGen/X86/stackmap.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=x86_64-apple-darwin -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7 | FileCheck %s
 ;
 ; Note: Print verbose stackmaps using -debug-only=stackmaps.
 
 ; CHECK-LABEL:  .section  __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
 ; CHECK-NEXT:   .byte 3

llvm/test/CodeGen/X86/statepoint-allocas.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -verify-machineinstrs < %s | FileCheck %s
 ; Check that we can lower a use of an alloca both as a deopt value (where the
 ; exact meaning is up to the consumer of the stackmap) and as an explicit spill
 ; slot used for GC.
 
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 

llvm/test/CodeGen/X86/statepoint-call-lowering.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -verify-machineinstrs < %s | FileCheck %s
 ; This file contains a collection of basic tests to ensure we didn't
 ; screw up normal call lowering when there are no deopt or gc arguments.
 
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 
 %struct = type { i64, i64 }

llvm/test/CodeGen/X86/statepoint-forward.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: opt -O3 -S < %s | FileCheck --check-prefix=CHECK-OPT %s
 ; RUN: llc -verify-machineinstrs < %s | FileCheck --check-prefix=CHECK-LLC %s
 ; These tests are targetted at making sure we don't retain information
 ; about memory which contains potential gc references across a statepoint.
 ; They're carefully written to only outlaw forwarding of references. 
 ; Depending on the collector, forwarding non-reference fields or
 ; constant null references may be perfectly legal. (If unimplemented.)
 ; The general structure of these tests is:

llvm/test/CodeGen/X86/statepoint-gctransition-call-lowering.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -verify-machineinstrs < %s | FileCheck %s
 ; This file contains a collection of basic tests to ensure we didn't
 ; screw up normal call lowering when a statepoint is a GC transition.
 
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 
 declare zeroext i1 @return_i1()

llvm/test/CodeGen/X86/statepoint-invoke.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -verify-machineinstrs < %s 2>&1 | FileCheck %s
 
 target triple = "x86_64-pc-linux-gnu"
 
 declare void @"some_call"(i64 addrspace(1)*)
 declare i64 addrspace(1)* @"some_other_call"(i64 addrspace(1)*)
 
 declare i32 @"personality_function"()

llvm/test/CodeGen/X86/statepoint-live-in.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc -verify-machineinstrs -O3 -restrict-statepoint-remat -debug-entry-values -stop-after=machineverifier < %s | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -verify-machineinstrs -O3 -restrict-statepoint-remat < %s | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare void @bar() #0
 declare void @baz()
 
 define void @test1(i32 %a) gc "statepoint-example" {

llvm/test/CodeGen/X86/statepoint-no-realign-stack.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -verify-machineinstrs -mcpu=skylake < %s | FileCheck %s
 
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 
 ; Shows a case where we spill a 32 byte value onto a stack which is only
 ; 16 byte aligned.  With stack realignment, we can use an aligned spill slot
 ; (if we think it's profitable), but without realignment, using a stack

llvm/test/CodeGen/X86/statepoint-stackmap-format.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple="x86_64-pc-linux-gnu" -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc < %s -verify-machineinstrs -stack-symbol-ordering=0 -mtriple="x86_64-pc-linux-gnu" | FileCheck %s
 ; RUN: llc < %s -verify-machineinstrs -stack-symbol-ordering=0 -mtriple="x86_64-pc-unknown-elf" | FileCheck %s
 
 ; This test is a sanity check to ensure statepoints are generating StackMap
 ; sections correctly.  This is not intended to be a rigorous test of the 
 ; StackMap format (see the stackmap tests for that).
 
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"

llvm/test/CodeGen/X86/statepoint-uniqueing.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple="x86_64-pc-linux-gnu" -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -verify-machineinstrs < %s | FileCheck %s
 
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 
 declare void @use(...)
 declare void @f()
 declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)

llvm/test/CodeGen/X86/statepoint-vector-bad-spill.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple="x86_64-pc-linux-gnu" -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -verify-machineinstrs -O3 < %s | FileCheck %s
 
 ; This is checking for a crash.
 
 target triple = "x86_64-pc-linux-gnu"
 
 define <2 x i8 addrspace(1)*> @test0(i8 addrspace(1)* %el, <2 x i8 addrspace(1)*>* %vec_ptr) gc "statepoint-example" {
 ; CHECK-LABEL: test0:

llvm/test/CodeGen/X86/statepoint-vector.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+
+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple="x86_64-pc-linux-gnu" -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -verify-machineinstrs -stack-symbol-ordering=0 -mcpu=nehalem -debug-only=stackmaps < %s | FileCheck %s
 ; REQUIRES: asserts
 
 target triple = "x86_64-pc-linux-gnu"
 
 ; Can we lower a single vector?
 define <2 x i8 addrspace(1)*> @test(<2 x i8 addrspace(1)*> %obj) gc "statepoint-example" {
 ; CHECK-LABEL: test:

llvm/test/CodeGen/X86/xray-custom-log.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=x86_64-unknown-linux-gnu -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -verify-machineinstrs -filetype=asm -o - -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s
 ; RUN: llc -verify-machineinstrs -filetype=asm -o - \
 ; RUN:     -mtriple=x86_64-unknown-linux-gnu -relocation-model=pic < %s | FileCheck %s -check-prefix=PIC
 
 define i32 @fn() nounwind noinline uwtable "function-instrument"="xray-always" {
     %eventptr = alloca i8
     %eventsize = alloca i32
     store i32 3, i32* %eventsize

llvm/test/CodeGen/X86/xray-typed-event-log.ll

+; Verify the call site info. If the call site info is not
+; in the valid state, an assert should be triggered.
+; RUN: llc < %s -debug-entry-values -mtriple=x86_64-unknown-linux-gnu -stop-after=machineverifier | FileCheck %s -check-prefix=CHECK-CALLSITE
+; CHECK-CALLSITE: callSites:
+
 ; RUN: llc -verify-machineinstrs -filetype=asm -o - -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s
 ; RUN: llc -verify-machineinstrs -filetype=asm -o - -mtriple=x86_64-unknown-linux-gnu \
 ; RUN:    -relocation-model=pic < %s | FileCheck %s -check-prefix=PIC
 
 define i32 @fn() nounwind noinline uwtable "function-instrument"="xray-always" {
     %eventptr = alloca i8
     %eventsize = alloca i32
     %eventtype = alloca i16