From d041f218100e482839a232ae9e23b073bf19b812 Mon Sep 17 00:00:00 2001 From: Matt Davis Date: Thu, 21 Jun 2018 17:59:52 +0000 Subject: [PATCH] [DebugInfo] Ignore DBG_VALUE instructions in PostRA Machine Sink Summary: The logic for handling the sinking of COPY instructions was generating different code when building with debug flags. The original code did not take into consideration debug instructions. This resulted in the registers in the DBG_VALUE instructions being treated as used, and prevented the COPY from being sunk. This patch avoids analyzing debug instructions when trying to sink COPY instructions. This patch also creates a routine from the code in MachineSinking::SinkInstruction to perform the logic of sinking an instruction along with its debug instructions. This functionality is used in multiple places, including the code for sinking COPY instrs. Reviewers: junbuml, javed.absar, MatzeB, bjope Reviewed By: bjope Subscribers: aprantl, probinson, thegameg, jonpa, bjope, vsk, kristof.beyls, JDevlieghere, llvm-commits Tags: #debug-info Differential Revision: https://reviews.llvm.org/D45637 llvm-svn: 335264 --- llvm/lib/CodeGen/MachineSink.cpp | 61 +++++++------ .../CodeGen/X86/postra-ignore-dbg-instrs.mir | 88 +++++++++++++++++++ 2 files changed, 124 insertions(+), 25 deletions(-) create mode 100644 llvm/test/CodeGen/X86/postra-ignore-dbg-instrs.mir diff --git a/llvm/lib/CodeGen/MachineSink.cpp b/llvm/lib/CodeGen/MachineSink.cpp index c09539d9903c..354f46e9e625 100644 --- a/llvm/lib/CodeGen/MachineSink.cpp +++ b/llvm/lib/CodeGen/MachineSink.cpp @@ -753,6 +753,37 @@ static bool SinkingPreventsImplicitNullCheck(MachineInstr &MI, MBP.LHS.getReg() == BaseReg; } +/// Sink an instruction and its associated debug instructions. +static void performSink(MachineInstr &MI, MachineBasicBlock &SuccToSinkTo, + MachineBasicBlock::iterator InsertPos) { + // Collect matching debug values. + SmallVector DbgValuesToSink; + collectDebugValues(MI, DbgValuesToSink); + + // If we cannot find a location to use (merge with), then we erase the debug + // location to prevent debug-info driven tools from potentially reporting + // wrong location information. + if (!SuccToSinkTo.empty() && InsertPos != SuccToSinkTo.end()) + MI.setDebugLoc(DILocation::getMergedLocation(MI.getDebugLoc(), + InsertPos->getDebugLoc())); + else + MI.setDebugLoc(DebugLoc()); + + // Move the instruction. + MachineBasicBlock *ParentBlock = MI.getParent(); + SuccToSinkTo.splice(InsertPos, ParentBlock, MI, + ++MachineBasicBlock::iterator(MI)); + + // Move previously adjacent debug value instructions to the insert position. + for (SmallVectorImpl::iterator DBI = DbgValuesToSink.begin(), + DBE = DbgValuesToSink.end(); + DBI != DBE; ++DBI) { + MachineInstr *DbgMI = *DBI; + SuccToSinkTo.splice(InsertPos, ParentBlock, DbgMI, + ++MachineBasicBlock::iterator(DbgMI)); + } +} + /// SinkInstruction - Determine whether it is safe to sink the specified machine /// instruction out of its current block into a successor. bool MachineSinking::SinkInstruction(MachineInstr &MI, bool &SawStore, @@ -866,30 +897,7 @@ bool MachineSinking::SinkInstruction(MachineInstr &MI, bool &SawStore, while (InsertPos != SuccToSinkTo->end() && InsertPos->isPHI()) ++InsertPos; - // collect matching debug values. - SmallVector DbgValuesToSink; - collectDebugValues(MI, DbgValuesToSink); - - // Merge or erase debug location to ensure consistent stepping in profilers - // and debuggers. - if (!SuccToSinkTo->empty() && InsertPos != SuccToSinkTo->end()) - MI.setDebugLoc(DILocation::getMergedLocation(MI.getDebugLoc(), - InsertPos->getDebugLoc())); - else - MI.setDebugLoc(DebugLoc()); - - - // Move the instruction. - SuccToSinkTo->splice(InsertPos, ParentBlock, MI, - ++MachineBasicBlock::iterator(MI)); - - // Move previously adjacent debug value instructions to the insert position. - for (SmallVectorImpl::iterator DBI = DbgValuesToSink.begin(), - DBE = DbgValuesToSink.end(); DBI != DBE; ++DBI) { - MachineInstr *DbgMI = *DBI; - SuccToSinkTo->splice(InsertPos, ParentBlock, DbgMI, - ++MachineBasicBlock::iterator(DbgMI)); - } + performSink(MI, *SuccToSinkTo, InsertPos); // Conservatively, clear any kill flags, since it's possible that they are no // longer correct. @@ -1118,6 +1126,9 @@ bool PostRAMachineSinking::tryToSinkCopy(MachineBasicBlock &CurBB, MachineInstr *MI = &*I; ++I; + if (MI->isDebugInstr()) + continue; + // Do not move any instruction across function call. if (MI->isCall()) return false; @@ -1158,7 +1169,7 @@ bool PostRAMachineSinking::tryToSinkCopy(MachineBasicBlock &CurBB, // block. clearKillFlags(MI, CurBB, UsedOpsInCopy, UsedRegUnits, TRI); MachineBasicBlock::iterator InsertPos = SuccBB->getFirstNonPHI(); - SuccBB->splice(InsertPos, &CurBB, MI); + performSink(*MI, *SuccBB, InsertPos); updateLiveIn(MI, SuccBB, UsedOpsInCopy, DefedRegsInCopy); Changed = true; diff --git a/llvm/test/CodeGen/X86/postra-ignore-dbg-instrs.mir b/llvm/test/CodeGen/X86/postra-ignore-dbg-instrs.mir new file mode 100644 index 000000000000..0286e6e68bf7 --- /dev/null +++ b/llvm/test/CodeGen/X86/postra-ignore-dbg-instrs.mir @@ -0,0 +1,88 @@ +# RUN: llc -mtriple=x86_64-none-linux-gnu -run-pass=postra-machine-sink -verify-machineinstrs -o - %s | FileCheck %s +# +# This test was originally generated from the following sample: +# +# int x0; +# extern void x3(int, int); +# void x1(int x2) { +# if (x0) +# x3(0, x2); +# } +# +# The code generates a COPY instruction which the PostRA Machine Sink pass will +# try to sink. Earlier versions were not performing the sink due to a +# DBG_VALUE instruction confusing the sinking algorithm. + +--- | + @x0 = common dso_local global i32 0, align 4, !dbg !0 + + define dso_local void @x1(i32) !dbg !11 { + %2 = alloca i32, align 4 + store i32 %0, i32* %2, align 4 + call void @llvm.dbg.declare(metadata i32* %2, metadata !14, metadata !DIExpression()), !dbg !16 + %3 = load i32, i32* @x0, align 4, !dbg !16 + %4 = icmp ne i32 %3, 0, !dbg !16 + br i1 %4, label %5, label %7, !dbg !16 + + ;