mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-03 18:29:48 +00:00
on X86 Atom. Some of our tests failed because the tail merging part of the BranchFolding pass was creating new basic blocks which did not contain live-in information. When the anti-dependency code in the Post-RA scheduler ran, it would sometimes rename the register containing the function return value because the fact that the return value was live-in to the subsequent block had been lost. To fix this, it is necessary to run the RegisterScavenging code in the BranchFolding pass. This patch makes sure that the register scavenging code is invoked in the X86 subtarget only when post-RA scheduling is being done. Post RA scheduling in the X86 subtarget is only done for Atom. This patch adds a new function to the TargetRegisterClass to control whether or not live-ins should be preserved during branch folding. This is necessary in order for the anti-dependency optimizations done during the PostRASchedulerList pass to work properly when doing Post-RA scheduling for the X86 in general and for the Intel Atom in particular. The patch adds and invokes the new function trackLivenessAfterRegAlloc() instead of using the existing requiresRegisterScavenging(). It changes BranchFolding.cpp to call trackLivenessAfterRegAlloc() instead of requiresRegisterScavenging(). It changes the all the targets that implemented requiresRegisterScavenging() to also implement trackLivenessAfterRegAlloc(). It adds an assertion in the Post RA scheduler to make sure that post RA liveness information is available when it is needed. It changes the X86 break-anti-dependencies test to use –mcpu=atom, in order to avoid running into the added assertion. Finally, this patch restores the use of anti-dependency checking (which was turned off temporarily for the 3.1 release) for Intel Atom in the Post RA scheduler. Patch by Andy Zhang! Thanks to Jakob and Anton for their reviews. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@155395 91177308-0d34-0410-b5e6-96231b3b80d8
95 lines
3.1 KiB
C++
95 lines
3.1 KiB
C++
//==- HexagonRegisterInfo.h - Hexagon Register Information Impl --*- C++ -*-==//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains the Hexagon implementation of the TargetRegisterInfo
|
|
// class.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef HexagonREGISTERINFO_H
|
|
#define HexagonREGISTERINFO_H
|
|
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
|
#include "llvm/MC/MachineLocation.h"
|
|
|
|
#define GET_REGINFO_HEADER
|
|
#include "HexagonGenRegisterInfo.inc"
|
|
|
|
//
|
|
// We try not to hard code the reserved registers in our code,
|
|
// so the following two macros were defined. However, there
|
|
// are still a few places that R11 and R10 are hard wired.
|
|
// See below. If, in the future, we decided to change the reserved
|
|
// register. Don't forget changing the following places.
|
|
//
|
|
// 1. the "Defs" set of STriw_pred in HexagonInstrInfo.td
|
|
// 2. the "Defs" set of LDri_pred in HexagonInstrInfo.td
|
|
// 3. the definition of "IntRegs" in HexagonRegisterInfo.td
|
|
// 4. the definition of "DoubleRegs" in HexagonRegisterInfo.td
|
|
//
|
|
#define HEXAGON_RESERVED_REG_1 Hexagon::R10
|
|
#define HEXAGON_RESERVED_REG_2 Hexagon::R11
|
|
|
|
namespace llvm {
|
|
|
|
class HexagonSubtarget;
|
|
class HexagonInstrInfo;
|
|
class Type;
|
|
|
|
struct HexagonRegisterInfo : public HexagonGenRegisterInfo {
|
|
HexagonSubtarget &Subtarget;
|
|
const HexagonInstrInfo &TII;
|
|
|
|
HexagonRegisterInfo(HexagonSubtarget &st, const HexagonInstrInfo &tii);
|
|
|
|
/// Code Generation virtual methods...
|
|
const uint16_t *getCalleeSavedRegs(const MachineFunction *MF = 0) const;
|
|
|
|
const TargetRegisterClass* const* getCalleeSavedRegClasses(
|
|
const MachineFunction *MF = 0) const;
|
|
|
|
BitVector getReservedRegs(const MachineFunction &MF) const;
|
|
|
|
void eliminateCallFramePseudoInstr(MachineFunction &MF,
|
|
MachineBasicBlock &MBB,
|
|
MachineBasicBlock::iterator I) const;
|
|
|
|
void eliminateFrameIndex(MachineBasicBlock::iterator II,
|
|
int SPAdj, RegScavenger *RS = NULL) const;
|
|
|
|
/// determineFrameLayout - Determine the size of the frame and maximum call
|
|
/// frame size.
|
|
void determineFrameLayout(MachineFunction &MF) const;
|
|
|
|
/// requiresRegisterScavenging - returns true since we may need scavenging for
|
|
/// a temporary register when generating hardware loop instructions.
|
|
bool requiresRegisterScavenging(const MachineFunction &MF) const {
|
|
return true;
|
|
}
|
|
|
|
bool trackLivenessAfterRegAlloc(const MachineFunction &MF) const {
|
|
return true;
|
|
}
|
|
|
|
// Debug information queries.
|
|
unsigned getRARegister() const;
|
|
unsigned getFrameRegister(const MachineFunction &MF) const;
|
|
unsigned getFrameRegister() const;
|
|
void getInitialFrameState(std::vector<MachineMove> &Moves) const;
|
|
unsigned getStackRegister() const;
|
|
|
|
// Exception handling queries.
|
|
unsigned getEHExceptionRegister() const;
|
|
unsigned getEHHandlerRegister() const;
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif
|