llvm/llvm/lib/Target/SystemZ/SystemZMachineScheduler.cpp

//-- SystemZMachineScheduler.cpp - SystemZ Scheduler Interface -*- C++ -*---==//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// -------------------------- Post RA scheduling ---------------------------- //
// SystemZPostRASchedStrategy is a scheduling strategy which is plugged into
// the MachineScheduler. It has a sorted Available set of SUs and a pickNode()
// implementation that looks to optimize decoder grouping and balance the
// usage of processor resources. Scheduler states are saved for the end
// region of each MBB, so that a successor block can learn from it.
//===----------------------------------------------------------------------===//

#include "SystemZMachineScheduler.h"
#include "llvm/CodeGen/MachineLoopInfo.h"

usingnamespacellvm;

#define DEBUG_TYPE …

#ifndef NDEBUG
// Print the set of SUs
void SystemZPostRASchedStrategy::SUSet::
dump(SystemZHazardRecognizer &HazardRec) const {
  dbgs() << "{";
  for (auto &SU : *this) {
    HazardRec.dumpSU(SU, dbgs());
    if (SU != *rbegin())
      dbgs() << ",  ";
  }
  dbgs() << "}\n";
}
#endif

// Try to find a single predecessor that would be interesting for the
// scheduler in the top-most region of MBB.
static MachineBasicBlock *getSingleSchedPred(MachineBasicBlock *MBB,
                                             const MachineLoop *Loop) { … }

void SystemZPostRASchedStrategy::
advanceTo(MachineBasicBlock::iterator NextBegin) { … }

void SystemZPostRASchedStrategy::initialize(ScheduleDAGMI *dag) { … }

void SystemZPostRASchedStrategy::enterMBB(MachineBasicBlock *NextMBB) { … }

void SystemZPostRASchedStrategy::leaveMBB() { … }

SystemZPostRASchedStrategy::
SystemZPostRASchedStrategy(const MachineSchedContext *C)
  : … { … }

SystemZPostRASchedStrategy::~SystemZPostRASchedStrategy() { … }

void SystemZPostRASchedStrategy::initPolicy(MachineBasicBlock::iterator Begin,
                                            MachineBasicBlock::iterator End,
                                            unsigned NumRegionInstrs) { … }

// Pick the next node to schedule.
SUnit *SystemZPostRASchedStrategy::pickNode(bool &IsTopNode) { … }

SystemZPostRASchedStrategy::Candidate::
Candidate(SUnit *SU_, SystemZHazardRecognizer &HazardRec) : … { … }

bool SystemZPostRASchedStrategy::Candidate::
operator<(const Candidate &other) { … }

void SystemZPostRASchedStrategy::schedNode(SUnit *SU, bool IsTopNode) { … }

void SystemZPostRASchedStrategy::releaseTopNode(SUnit *SU) { … }