mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-09 07:46:06 +00:00
b42ffa1283
Large callframes (calls with several hundreds or thousands or parameters) could lead to situations in which the emergency spillslot is out of range to be addressed relative to the stack pointer. This commit forces the use of a frame pointer in the presence of large callframes. This commit does several things: - Compute max callframe size at the end of instruction selection. - Add mirFileLoaded target callback. Use it to compute the max callframe size after loading a .mir file when the size wasn't specified in the file. - Let TargetFrameLowering::hasFP() return true if there exists a callframe > 255 bytes. - Always place the emergency spillslot close to FP if we have a frame pointer. - Note that `useFPForScavengingIndex()` would previously return false when a base pointer was available leading to the emergency spillslot getting allocated late (that's the whole effect of this callback). Which made no sense to me so I took this case out: Even though the emergency spillslot is technically not referenced by FP in this case we still want it allocated early. Differential Revision: https://reviews.llvm.org/D40876 llvm-svn: 322200
117 lines
3.9 KiB
C++
117 lines
3.9 KiB
C++
//===- TargetSubtargetInfo.cpp - General Target Information ----------------==//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
/// \file This file describes the general parts of a Subtarget.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/CodeGen/TargetSubtargetInfo.h"
|
|
#include "llvm/ADT/Optional.h"
|
|
#include "llvm/CodeGen/MachineInstr.h"
|
|
#include "llvm/CodeGen/TargetInstrInfo.h"
|
|
#include "llvm/CodeGen/TargetSchedule.h"
|
|
#include "llvm/MC/MCInst.h"
|
|
#include "llvm/Support/Format.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <string>
|
|
|
|
using namespace llvm;
|
|
|
|
TargetSubtargetInfo::TargetSubtargetInfo(
|
|
const Triple &TT, StringRef CPU, StringRef FS,
|
|
ArrayRef<SubtargetFeatureKV> PF, ArrayRef<SubtargetFeatureKV> PD,
|
|
const SubtargetInfoKV *ProcSched, const MCWriteProcResEntry *WPR,
|
|
const MCWriteLatencyEntry *WL, const MCReadAdvanceEntry *RA,
|
|
const InstrStage *IS, const unsigned *OC, const unsigned *FP)
|
|
: MCSubtargetInfo(TT, CPU, FS, PF, PD, ProcSched, WPR, WL, RA, IS, OC, FP) {
|
|
}
|
|
|
|
TargetSubtargetInfo::~TargetSubtargetInfo() = default;
|
|
|
|
bool TargetSubtargetInfo::enableAtomicExpand() const {
|
|
return true;
|
|
}
|
|
|
|
bool TargetSubtargetInfo::enableMachineScheduler() const {
|
|
return false;
|
|
}
|
|
|
|
bool TargetSubtargetInfo::enableJoinGlobalCopies() const {
|
|
return enableMachineScheduler();
|
|
}
|
|
|
|
bool TargetSubtargetInfo::enableRALocalReassignment(
|
|
CodeGenOpt::Level OptLevel) const {
|
|
return true;
|
|
}
|
|
|
|
bool TargetSubtargetInfo::enableAdvancedRASplitCost() const {
|
|
return false;
|
|
}
|
|
|
|
bool TargetSubtargetInfo::enablePostRAScheduler() const {
|
|
return getSchedModel().PostRAScheduler;
|
|
}
|
|
|
|
bool TargetSubtargetInfo::useAA() const {
|
|
return false;
|
|
}
|
|
|
|
static std::string createSchedInfoStr(unsigned Latency,
|
|
Optional<double> RThroughput) {
|
|
static const char *SchedPrefix = " sched: [";
|
|
std::string Comment;
|
|
raw_string_ostream CS(Comment);
|
|
if (Latency > 0 && RThroughput.hasValue())
|
|
CS << SchedPrefix << Latency << format(":%2.2f", RThroughput.getValue())
|
|
<< "]";
|
|
else if (Latency > 0)
|
|
CS << SchedPrefix << Latency << ":?]";
|
|
else if (RThroughput.hasValue())
|
|
CS << SchedPrefix << "?:" << RThroughput.getValue() << "]";
|
|
CS.flush();
|
|
return Comment;
|
|
}
|
|
|
|
/// Returns string representation of scheduler comment
|
|
std::string TargetSubtargetInfo::getSchedInfoStr(const MachineInstr &MI) const {
|
|
if (MI.isPseudo() || MI.isTerminator())
|
|
return std::string();
|
|
// We don't cache TSchedModel because it depends on TargetInstrInfo
|
|
// that could be changed during the compilation
|
|
TargetSchedModel TSchedModel;
|
|
TSchedModel.init(getSchedModel(), this, getInstrInfo());
|
|
unsigned Latency = TSchedModel.computeInstrLatency(&MI);
|
|
Optional<double> RThroughput = TSchedModel.computeInstrRThroughput(&MI);
|
|
return createSchedInfoStr(Latency, RThroughput);
|
|
}
|
|
|
|
/// Returns string representation of scheduler comment
|
|
std::string TargetSubtargetInfo::getSchedInfoStr(MCInst const &MCI) const {
|
|
// We don't cache TSchedModel because it depends on TargetInstrInfo
|
|
// that could be changed during the compilation
|
|
TargetSchedModel TSchedModel;
|
|
TSchedModel.init(getSchedModel(), this, getInstrInfo());
|
|
unsigned Latency;
|
|
if (TSchedModel.hasInstrSchedModel())
|
|
Latency = TSchedModel.computeInstrLatency(MCI.getOpcode());
|
|
else if (TSchedModel.hasInstrItineraries()) {
|
|
auto *ItinData = TSchedModel.getInstrItineraries();
|
|
Latency = ItinData->getStageLatency(
|
|
getInstrInfo()->get(MCI.getOpcode()).getSchedClass());
|
|
} else
|
|
return std::string();
|
|
Optional<double> RThroughput =
|
|
TSchedModel.computeInstrRThroughput(MCI.getOpcode());
|
|
return createSchedInfoStr(Latency, RThroughput);
|
|
}
|
|
|
|
void TargetSubtargetInfo::mirFileLoaded(MachineFunction &MF) const {
|
|
}
|