Re-juggle defs and copy processing · jmorse/llvm-project@720876f (original) (raw)

`@@ -629,7 +629,7 @@ class LiveDebugValues : public MachineFunctionPass {

`

629

629

`void recordEntryValue(const MachineInstr &MI,

`

630

630

`const DefinedRegsSet &DefinedRegs,

`

631

631

` OpenRangesSet &OpenRanges, VarLocMap &VarLocIDs);

`

632

``

`-

bool transferRegisterCopy(MachineInstr &MI, OpenRangesSet &OpenRanges,

`

``

632

`+

void transferRegisterCopy(MachineInstr &MI, OpenRangesSet &OpenRanges,

`

633

633

` VarLocMap &VarLocIDs, TransferMap *Transfers);

`

634

634

`void transferRegisterDef(MachineInstr &MI, OpenRangesSet &OpenRanges,

`

635

635

` VarLocMap &VarLocIDs, TransferMap *Transfers);

`

`@@ -1073,6 +1073,15 @@ void LiveDebugValues::transferRegisterDef(

`

1073

1073

`if (MI.isMetaInstruction())

`

1074

1074

`return;

`

1075

1075

``

``

1076

`+

// Skip identity copies.

`

``

1077

`+

auto DestSrc = TII->isCopyInstr(MI);

`

``

1078

`+

if (DestSrc) {

`

``

1079

`+

const MachineOperand *DestRegOp = DestSrc->Destination;

`

``

1080

`+

const MachineOperand *SrcRegOp = DestSrc->Source;

`

``

1081

`+

if (DestRegOp->getReg() == SrcRegOp->getReg())

`

``

1082

`+

return;

`

``

1083

`+

}

`

``

1084

+

1076

1085

` MachineFunction *MF = MI.getMF();

`

1077

1086

`const TargetLowering *TLI = MF->getSubtarget().getTargetLowering();

`

1078

1087

`unsigned SP = TLI->getStackPointerRegisterToSaveRestore();

`

`@@ -1291,19 +1300,19 @@ return;

`

1291

1300

`/// If \p MI is a register copy instruction, that copies a previously tracked

`

1292

1301

`/// value from one register to another register that is callee saved, we

`

1293

1302

`/// create new DBG_VALUE instruction described with copy destination register.

`

1294

``

`-

bool LiveDebugValues::transferRegisterCopy(MachineInstr &MI,

`

``

1303

`+

void LiveDebugValues::transferRegisterCopy(MachineInstr &MI,

`

1295

1304

` OpenRangesSet &OpenRanges,

`

1296

1305

` VarLocMap &VarLocIDs,

`

1297

1306

` TransferMap *Transfers) {

`

1298

1307

`auto DestSrc = TII->isCopyInstr(MI);

`

1299

1308

`if (!DestSrc)

`

1300

``

`-

return false;

`

``

1309

`+

return;

`

1301

1310

``

1302

1311

`const MachineOperand *DestRegOp = DestSrc->Destination;

`

1303

1312

`const MachineOperand *SrcRegOp = DestSrc->Source;

`

1304

1313

``

1305

1314

`if (!DestRegOp->isDef())

`

1306

``

`-

return false;

`

``

1315

`+

return;

`

1307

1316

``

1308

1317

`auto isCalleeSavedReg = [&](unsigned Reg) {

`

1309

1318

`for (MCRegAliasIterator RAI(Reg, TRI, true); RAI.isValid(); ++RAI)

`

`@@ -1316,15 +1325,15 @@ bool LiveDebugValues::transferRegisterCopy(MachineInstr &MI,

`

1316

1325

` Register DestReg = DestRegOp->getReg();

`

1317

1326

``

1318

1327

`if (SrcReg == DestReg)

`

1319

``

`-

return true; // We've handled this identity copy by ignoring it.

`

``

1328

`+

return;

`

1320

1329

``

1321

1330

`// We want to recognize instructions where destination register is callee

`

1322

1331

`// saved register. If register that could be clobbered by the call is

`

1323

1332

`// included, there would be a great chance that it is going to be clobbered

`

1324

1333

`// soon. It is more likely that previous register location, which is callee

`

1325

1334

`// saved, is going to stay unclobbered longer, even if it is killed.

`

1326

1335

`if (!isCalleeSavedReg(DestReg))

`

1327

``

`-

return false;

`

``

1336

`+

return;

`

1328

1337

``

1329

1338

`// Remember an entry value movement. If we encounter a new debug value of

`

1330

1339

`// a parameter describing only a moving of the value around, rather then

`

`@@ -1350,15 +1359,25 @@ bool LiveDebugValues::transferRegisterCopy(MachineInstr &MI,

`

1350

1359

` }

`

1351

1360

``

1352

1361

`if (!SrcRegOp->isKill())

`

1353

``

`-

return false;

`

``

1362

`+

return;

`

``

1363

+

``

1364

`+

#if 0

`

``

1365

`+

SmallSet<Register, 16> SubRegs;

`

``

1366

`+

for (MCSubRegIndexIterator SRI(DestReg, TRI); SRI.isValid(); ++SRI)

`

``

1367

`+

SubRegs.insert(SRI.getSubReg());

`

``

1368

`+

#endif

`

1354

1369

``

1355

1370

` SmallVector<LocIndex, 8> SrcLocs;

`

1356

1371

` VarLocSet DstLocs(Alloc);

`

1357

1372

`for (uint64_t ID : OpenRanges.getVarLocs()) {

`

1358

1373

` LocIndex Idx = LocIndex::fromRawInteger(ID);

`

1359

1374

`if (VarLocIDs[Idx].isDescribedByReg() == SrcReg) {

`

1360

1375

` SrcLocs.push_back(Idx);

`

1361

``

`-

} else if (VarLocIDs[Idx].isDescribedByReg() == DestReg) {

`

``

1376

`+

} else if (VarLocIDs[Idx].isDescribedByReg() == DestReg //||

`

``

1377

`+

#if 0

`

``

1378

`+

SubRegs.count(VarLocIDs[Idx].isDescribedByReg())) {

`

``

1379

`+

#endif

`

``

1380

`+

) {

`

1362

1381

` DstLocs.set(ID);

`

1363

1382

` }

`

1364

1383

` }

`

`@@ -1370,7 +1389,7 @@ bool LiveDebugValues::transferRegisterCopy(MachineInstr &MI,

`

1370

1389

``

1371

1390

` OpenRanges.erase(DstLocs, VarLocIDs);

`

1372

1391

``

1373

``

`-

return true;

`

``

1392

`+

return;

`

1374

1393

`}

`

1375

1394

``

1376

1395

`/// Terminate all open ranges at the end of the current basic block.

`

`@@ -1461,9 +1480,8 @@ void LiveDebugValues::accumulateFragmentMap(MachineInstr &MI,

`

1461

1480

`void LiveDebugValues::process(MachineInstr &MI, OpenRangesSet &OpenRanges,

`

1462

1481

` VarLocMap &VarLocIDs, TransferMap *Transfers) {

`

1463

1482

`transferDebugValue(MI, OpenRanges, VarLocIDs);

`

1464

``

`-

if (transferRegisterCopy(MI, OpenRanges, VarLocIDs, Transfers))

`

1465

``

`-

return;

`

1466

1483

`transferRegisterDef(MI, OpenRanges, VarLocIDs, Transfers);

`

``

1484

`+

transferRegisterCopy(MI, OpenRanges, VarLocIDs, Transfers);

`

1467

1485

`transferSpillOrRestoreInst(MI, OpenRanges, VarLocIDs, Transfers);

`

1468

1486

`}

`

1469

1487

``