2013-05-07 00:15:19 +08:00
|
|
|
//===-- SystemZInstrInfo.cpp - SystemZ instruction information ------------===//
|
|
|
|
//
|
|
|
|
// 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 SystemZ implementation of the TargetInstrInfo class.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2017-01-25 06:10:43 +08:00
|
|
|
#include "MCTargetDesc/SystemZMCTargetDesc.h"
|
|
|
|
#include "SystemZ.h"
|
2013-05-07 00:15:19 +08:00
|
|
|
#include "SystemZInstrBuilder.h"
|
2017-01-25 06:10:43 +08:00
|
|
|
#include "SystemZInstrInfo.h"
|
|
|
|
#include "SystemZSubtarget.h"
|
|
|
|
#include "llvm/CodeGen/LiveInterval.h"
|
2016-05-10 16:09:37 +08:00
|
|
|
#include "llvm/CodeGen/LiveIntervalAnalysis.h"
|
2017-01-25 06:10:43 +08:00
|
|
|
#include "llvm/CodeGen/LiveVariables.h"
|
|
|
|
#include "llvm/CodeGen/MachineBasicBlock.h"
|
|
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
|
|
#include "llvm/CodeGen/MachineInstr.h"
|
|
|
|
#include "llvm/CodeGen/MachineMemOperand.h"
|
|
|
|
#include "llvm/CodeGen/MachineOperand.h"
|
2013-07-02 23:28:56 +08:00
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
2017-01-25 06:10:43 +08:00
|
|
|
#include "llvm/CodeGen/SlotIndexes.h"
|
|
|
|
#include "llvm/MC/MCInstrDesc.h"
|
|
|
|
#include "llvm/MC/MCRegisterInfo.h"
|
|
|
|
#include "llvm/Support/BranchProbability.h"
|
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include "llvm/Support/MathExtras.h"
|
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
#include "llvm/Target/TargetMachine.h"
|
|
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
|
|
|
#include <cassert>
|
|
|
|
#include <cstdint>
|
|
|
|
#include <iterator>
|
2013-05-07 00:15:19 +08:00
|
|
|
|
2014-04-22 10:03:14 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2013-11-19 08:57:56 +08:00
|
|
|
#define GET_INSTRINFO_CTOR_DTOR
|
2013-05-07 00:15:19 +08:00
|
|
|
#define GET_INSTRMAP_INFO
|
|
|
|
#include "SystemZGenInstrInfo.inc"
|
|
|
|
|
2013-07-31 19:36:35 +08:00
|
|
|
// Return a mask with Count low bits set.
|
|
|
|
static uint64_t allOnes(unsigned int Count) {
|
|
|
|
return Count == 0 ? 0 : (uint64_t(1) << (Count - 1) << 1) - 1;
|
|
|
|
}
|
|
|
|
|
2013-10-01 19:26:28 +08:00
|
|
|
// Reg should be a 32-bit GPR. Return true if it is a high register rather
|
|
|
|
// than a low register.
|
|
|
|
static bool isHighReg(unsigned int Reg) {
|
|
|
|
if (SystemZ::GRH32BitRegClass.contains(Reg))
|
|
|
|
return true;
|
|
|
|
assert(SystemZ::GR32BitRegClass.contains(Reg) && "Invalid GRX32");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-11-19 08:57:56 +08:00
|
|
|
// Pin the vtable to this file.
|
|
|
|
void SystemZInstrInfo::anchor() {}
|
|
|
|
|
2014-06-27 15:01:17 +08:00
|
|
|
SystemZInstrInfo::SystemZInstrInfo(SystemZSubtarget &sti)
|
2013-05-07 00:15:19 +08:00
|
|
|
: SystemZGenInstrInfo(SystemZ::ADJCALLSTACKDOWN, SystemZ::ADJCALLSTACKUP),
|
2014-06-27 15:01:17 +08:00
|
|
|
RI(), STI(sti) {
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// MI is a 128-bit load or store. Split it into two 64-bit loads or stores,
|
|
|
|
// each having the opcode given by NewOpcode.
|
|
|
|
void SystemZInstrInfo::splitMove(MachineBasicBlock::iterator MI,
|
|
|
|
unsigned NewOpcode) const {
|
|
|
|
MachineBasicBlock *MBB = MI->getParent();
|
|
|
|
MachineFunction &MF = *MBB->getParent();
|
|
|
|
|
|
|
|
// Get two load or store instructions. Use the original instruction for one
|
2014-01-25 01:20:08 +08:00
|
|
|
// of them (arbitrarily the second here) and create a clone for the other.
|
2016-07-12 09:39:01 +08:00
|
|
|
MachineInstr *EarlierMI = MF.CloneMachineInstr(&*MI);
|
2013-05-07 00:15:19 +08:00
|
|
|
MBB->insert(MI, EarlierMI);
|
|
|
|
|
2017-03-17 14:47:08 +08:00
|
|
|
// Set up the two 64-bit registers and remember super reg and its flags.
|
2013-05-07 00:15:19 +08:00
|
|
|
MachineOperand &HighRegOp = EarlierMI->getOperand(0);
|
|
|
|
MachineOperand &LowRegOp = MI->getOperand(0);
|
2017-03-17 14:47:08 +08:00
|
|
|
unsigned Reg128 = LowRegOp.getReg();
|
|
|
|
unsigned Reg128Killed = getKillRegState(LowRegOp.isKill());
|
|
|
|
unsigned Reg128Undef = getUndefRegState(LowRegOp.isUndef());
|
2013-09-30 18:28:35 +08:00
|
|
|
HighRegOp.setReg(RI.getSubReg(HighRegOp.getReg(), SystemZ::subreg_h64));
|
|
|
|
LowRegOp.setReg(RI.getSubReg(LowRegOp.getReg(), SystemZ::subreg_l64));
|
2013-05-07 00:15:19 +08:00
|
|
|
|
2017-03-17 14:47:08 +08:00
|
|
|
if (MI->mayStore()) {
|
|
|
|
// Add implicit uses of the super register in case one of the subregs is
|
|
|
|
// undefined. We could track liveness and skip storing an undefined
|
|
|
|
// subreg, but this is hopefully rare (discovered with llvm-stress).
|
|
|
|
// If Reg128 was killed, set kill flag on MI.
|
|
|
|
unsigned Reg128UndefImpl = (Reg128Undef | RegState::Implicit);
|
|
|
|
MachineInstrBuilder(MF, EarlierMI).addReg(Reg128, Reg128UndefImpl);
|
|
|
|
MachineInstrBuilder(MF, MI).addReg(Reg128, (Reg128UndefImpl | Reg128Killed));
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
// The address in the first (high) instruction is already correct.
|
|
|
|
// Adjust the offset in the second (low) instruction.
|
|
|
|
MachineOperand &HighOffsetOp = EarlierMI->getOperand(2);
|
|
|
|
MachineOperand &LowOffsetOp = MI->getOperand(2);
|
|
|
|
LowOffsetOp.setImm(LowOffsetOp.getImm() + 8);
|
|
|
|
|
2017-04-24 20:40:28 +08:00
|
|
|
// Clear the kill flags on the registers in the first instruction.
|
|
|
|
if (EarlierMI->getOperand(0).isReg() && EarlierMI->getOperand(0).isUse())
|
|
|
|
EarlierMI->getOperand(0).setIsKill(false);
|
2015-10-10 15:14:24 +08:00
|
|
|
EarlierMI->getOperand(1).setIsKill(false);
|
2015-10-26 23:03:41 +08:00
|
|
|
EarlierMI->getOperand(3).setIsKill(false);
|
2015-10-10 15:14:24 +08:00
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
// Set the opcodes.
|
|
|
|
unsigned HighOpcode = getOpcodeForOffset(NewOpcode, HighOffsetOp.getImm());
|
|
|
|
unsigned LowOpcode = getOpcodeForOffset(NewOpcode, LowOffsetOp.getImm());
|
|
|
|
assert(HighOpcode && LowOpcode && "Both offsets should be in range");
|
|
|
|
|
|
|
|
EarlierMI->setDesc(get(HighOpcode));
|
|
|
|
MI->setDesc(get(LowOpcode));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Split ADJDYNALLOC instruction MI.
|
|
|
|
void SystemZInstrInfo::splitAdjDynAlloc(MachineBasicBlock::iterator MI) const {
|
|
|
|
MachineBasicBlock *MBB = MI->getParent();
|
|
|
|
MachineFunction &MF = *MBB->getParent();
|
2016-07-29 02:40:00 +08:00
|
|
|
MachineFrameInfo &MFFrame = MF.getFrameInfo();
|
2013-05-07 00:15:19 +08:00
|
|
|
MachineOperand &OffsetMO = MI->getOperand(2);
|
|
|
|
|
2016-07-29 02:40:00 +08:00
|
|
|
uint64_t Offset = (MFFrame.getMaxCallFrameSize() +
|
2013-05-07 00:15:19 +08:00
|
|
|
SystemZMC::CallFrameSize +
|
|
|
|
OffsetMO.getImm());
|
|
|
|
unsigned NewOpcode = getOpcodeForOffset(SystemZ::LA, Offset);
|
|
|
|
assert(NewOpcode && "No support for huge argument lists yet");
|
|
|
|
MI->setDesc(get(NewOpcode));
|
|
|
|
OffsetMO.setImm(Offset);
|
|
|
|
}
|
|
|
|
|
2013-10-01 21:02:28 +08:00
|
|
|
// MI is an RI-style pseudo instruction. Replace it with LowOpcode
|
|
|
|
// if the first operand is a low GR32 and HighOpcode if the first operand
|
|
|
|
// is a high GR32. ConvertHigh is true if LowOpcode takes a signed operand
|
|
|
|
// and HighOpcode takes an unsigned 32-bit operand. In those cases,
|
|
|
|
// MI has the same kind of operand as LowOpcode, so needs to be converted
|
|
|
|
// if HighOpcode is used.
|
2016-06-30 08:01:54 +08:00
|
|
|
void SystemZInstrInfo::expandRIPseudo(MachineInstr &MI, unsigned LowOpcode,
|
2013-10-01 21:02:28 +08:00
|
|
|
unsigned HighOpcode,
|
|
|
|
bool ConvertHigh) const {
|
2016-06-30 08:01:54 +08:00
|
|
|
unsigned Reg = MI.getOperand(0).getReg();
|
2013-10-01 21:02:28 +08:00
|
|
|
bool IsHigh = isHighReg(Reg);
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.setDesc(get(IsHigh ? HighOpcode : LowOpcode));
|
2013-10-01 21:02:28 +08:00
|
|
|
if (IsHigh && ConvertHigh)
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.getOperand(1).setImm(uint32_t(MI.getOperand(1).getImm()));
|
2013-10-01 21:02:28 +08:00
|
|
|
}
|
|
|
|
|
2013-10-01 22:53:46 +08:00
|
|
|
// MI is a three-operand RIE-style pseudo instruction. Replace it with
|
2015-10-09 15:19:16 +08:00
|
|
|
// LowOpcodeK if the registers are both low GR32s, otherwise use a move
|
2013-10-01 22:53:46 +08:00
|
|
|
// followed by HighOpcode or LowOpcode, depending on whether the target
|
|
|
|
// is a high or low GR32.
|
2016-06-30 08:01:54 +08:00
|
|
|
void SystemZInstrInfo::expandRIEPseudo(MachineInstr &MI, unsigned LowOpcode,
|
2013-10-01 22:53:46 +08:00
|
|
|
unsigned LowOpcodeK,
|
|
|
|
unsigned HighOpcode) const {
|
2016-06-30 08:01:54 +08:00
|
|
|
unsigned DestReg = MI.getOperand(0).getReg();
|
|
|
|
unsigned SrcReg = MI.getOperand(1).getReg();
|
2013-10-01 22:53:46 +08:00
|
|
|
bool DestIsHigh = isHighReg(DestReg);
|
|
|
|
bool SrcIsHigh = isHighReg(SrcReg);
|
|
|
|
if (!DestIsHigh && !SrcIsHigh)
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.setDesc(get(LowOpcodeK));
|
2013-10-01 22:53:46 +08:00
|
|
|
else {
|
2016-06-30 08:01:54 +08:00
|
|
|
emitGRX32Move(*MI.getParent(), MI, MI.getDebugLoc(), DestReg, SrcReg,
|
2017-01-18 16:32:54 +08:00
|
|
|
SystemZ::LR, 32, MI.getOperand(1).isKill(),
|
|
|
|
MI.getOperand(1).isUndef());
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.setDesc(get(DestIsHigh ? HighOpcode : LowOpcode));
|
|
|
|
MI.getOperand(1).setReg(DestReg);
|
|
|
|
MI.tieOperands(0, 1);
|
2013-10-01 22:53:46 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-01 19:26:28 +08:00
|
|
|
// MI is an RXY-style pseudo instruction. Replace it with LowOpcode
|
|
|
|
// if the first operand is a low GR32 and HighOpcode if the first operand
|
|
|
|
// is a high GR32.
|
2016-06-30 08:01:54 +08:00
|
|
|
void SystemZInstrInfo::expandRXYPseudo(MachineInstr &MI, unsigned LowOpcode,
|
2013-10-01 19:26:28 +08:00
|
|
|
unsigned HighOpcode) const {
|
2016-06-30 08:01:54 +08:00
|
|
|
unsigned Reg = MI.getOperand(0).getReg();
|
2013-10-01 19:26:28 +08:00
|
|
|
unsigned Opcode = getOpcodeForOffset(isHighReg(Reg) ? HighOpcode : LowOpcode,
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.getOperand(2).getImm());
|
|
|
|
MI.setDesc(get(Opcode));
|
2013-10-01 19:26:28 +08:00
|
|
|
}
|
|
|
|
|
2016-11-28 21:34:08 +08:00
|
|
|
// MI is a load-on-condition pseudo instruction with a single register
|
|
|
|
// (source or destination) operand. Replace it with LowOpcode if the
|
|
|
|
// register is a low GR32 and HighOpcode if the register is a high GR32.
|
|
|
|
void SystemZInstrInfo::expandLOCPseudo(MachineInstr &MI, unsigned LowOpcode,
|
|
|
|
unsigned HighOpcode) const {
|
|
|
|
unsigned Reg = MI.getOperand(0).getReg();
|
|
|
|
unsigned Opcode = isHighReg(Reg) ? HighOpcode : LowOpcode;
|
|
|
|
MI.setDesc(get(Opcode));
|
|
|
|
}
|
|
|
|
|
|
|
|
// MI is a load-register-on-condition pseudo instruction. Replace it with
|
|
|
|
// LowOpcode if source and destination are both low GR32s and HighOpcode if
|
|
|
|
// source and destination are both high GR32s.
|
|
|
|
void SystemZInstrInfo::expandLOCRPseudo(MachineInstr &MI, unsigned LowOpcode,
|
|
|
|
unsigned HighOpcode) const {
|
|
|
|
unsigned DestReg = MI.getOperand(0).getReg();
|
|
|
|
unsigned SrcReg = MI.getOperand(2).getReg();
|
|
|
|
bool DestIsHigh = isHighReg(DestReg);
|
|
|
|
bool SrcIsHigh = isHighReg(SrcReg);
|
|
|
|
|
|
|
|
if (!DestIsHigh && !SrcIsHigh)
|
|
|
|
MI.setDesc(get(LowOpcode));
|
|
|
|
else if (DestIsHigh && SrcIsHigh)
|
|
|
|
MI.setDesc(get(HighOpcode));
|
|
|
|
|
|
|
|
// If we were unable to implement the pseudo with a single instruction, we
|
|
|
|
// need to convert it back into a branch sequence. This cannot be done here
|
|
|
|
// since the caller of expandPostRAPseudo does not handle changes to the CFG
|
|
|
|
// correctly. This change is defered to the SystemZExpandPseudo pass.
|
|
|
|
}
|
|
|
|
|
2013-10-01 20:49:07 +08:00
|
|
|
// MI is an RR-style pseudo instruction that zero-extends the low Size bits
|
|
|
|
// of one GRX32 into another. Replace it with LowOpcode if both operands
|
|
|
|
// are low registers, otherwise use RISB[LH]G.
|
2016-06-30 08:01:54 +08:00
|
|
|
void SystemZInstrInfo::expandZExtPseudo(MachineInstr &MI, unsigned LowOpcode,
|
2013-10-01 20:49:07 +08:00
|
|
|
unsigned Size) const {
|
2017-03-22 14:03:32 +08:00
|
|
|
MachineInstrBuilder MIB =
|
|
|
|
emitGRX32Move(*MI.getParent(), MI, MI.getDebugLoc(),
|
|
|
|
MI.getOperand(0).getReg(), MI.getOperand(1).getReg(), LowOpcode,
|
|
|
|
Size, MI.getOperand(1).isKill(), MI.getOperand(1).isUndef());
|
|
|
|
|
|
|
|
// Keep the remaining operands as-is.
|
|
|
|
for (unsigned I = 2; I < MI.getNumOperands(); ++I)
|
|
|
|
MIB.add(MI.getOperand(I));
|
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.eraseFromParent();
|
2013-10-01 20:49:07 +08:00
|
|
|
}
|
|
|
|
|
2016-04-24 21:57:49 +08:00
|
|
|
void SystemZInstrInfo::expandLoadStackGuard(MachineInstr *MI) const {
|
|
|
|
MachineBasicBlock *MBB = MI->getParent();
|
|
|
|
MachineFunction &MF = *MBB->getParent();
|
2017-05-24 21:15:48 +08:00
|
|
|
const unsigned Reg64 = MI->getOperand(0).getReg();
|
|
|
|
const unsigned Reg32 = RI.getSubReg(Reg64, SystemZ::subreg_l32);
|
2016-04-24 21:57:49 +08:00
|
|
|
|
2017-05-24 21:15:48 +08:00
|
|
|
// EAR can only load the low subregister so us a shift for %a0 to produce
|
|
|
|
// the GR containing %a0 and %a1.
|
2016-04-24 21:57:49 +08:00
|
|
|
|
|
|
|
// ear <reg>, %a0
|
2017-05-24 21:15:48 +08:00
|
|
|
BuildMI(*MBB, MI, MI->getDebugLoc(), get(SystemZ::EAR), Reg32)
|
|
|
|
.addReg(SystemZ::A0)
|
|
|
|
.addReg(Reg64, RegState::ImplicitDefine);
|
2016-04-24 21:57:49 +08:00
|
|
|
|
|
|
|
// sllg <reg>, <reg>, 32
|
2017-05-24 21:15:48 +08:00
|
|
|
BuildMI(*MBB, MI, MI->getDebugLoc(), get(SystemZ::SLLG), Reg64)
|
|
|
|
.addReg(Reg64)
|
|
|
|
.addReg(0)
|
|
|
|
.addImm(32);
|
2016-04-24 21:57:49 +08:00
|
|
|
|
|
|
|
// ear <reg>, %a1
|
2017-05-24 21:15:48 +08:00
|
|
|
BuildMI(*MBB, MI, MI->getDebugLoc(), get(SystemZ::EAR), Reg32)
|
|
|
|
.addReg(SystemZ::A1);
|
2016-04-24 21:57:49 +08:00
|
|
|
|
|
|
|
// lg <reg>, 40(<reg>)
|
|
|
|
MI->setDesc(get(SystemZ::LG));
|
2017-05-24 21:15:48 +08:00
|
|
|
MachineInstrBuilder(MF, MI).addReg(Reg64).addImm(40).addReg(0);
|
2016-04-24 21:57:49 +08:00
|
|
|
}
|
|
|
|
|
2013-10-01 19:26:28 +08:00
|
|
|
// Emit a zero-extending move from 32-bit GPR SrcReg to 32-bit GPR
|
|
|
|
// DestReg before MBBI in MBB. Use LowLowOpcode when both DestReg and SrcReg
|
|
|
|
// are low registers, otherwise use RISB[LH]G. Size is the number of bits
|
|
|
|
// taken from the low end of SrcReg (8 for LLCR, 16 for LLHR and 32 for LR).
|
|
|
|
// KillSrc is true if this move is the last use of SrcReg.
|
2017-03-22 14:03:32 +08:00
|
|
|
MachineInstrBuilder
|
|
|
|
SystemZInstrInfo::emitGRX32Move(MachineBasicBlock &MBB,
|
|
|
|
MachineBasicBlock::iterator MBBI,
|
|
|
|
const DebugLoc &DL, unsigned DestReg,
|
|
|
|
unsigned SrcReg, unsigned LowLowOpcode,
|
|
|
|
unsigned Size, bool KillSrc,
|
|
|
|
bool UndefSrc) const {
|
2013-10-01 19:26:28 +08:00
|
|
|
unsigned Opcode;
|
|
|
|
bool DestIsHigh = isHighReg(DestReg);
|
|
|
|
bool SrcIsHigh = isHighReg(SrcReg);
|
|
|
|
if (DestIsHigh && SrcIsHigh)
|
|
|
|
Opcode = SystemZ::RISBHH;
|
|
|
|
else if (DestIsHigh && !SrcIsHigh)
|
|
|
|
Opcode = SystemZ::RISBHL;
|
|
|
|
else if (!DestIsHigh && SrcIsHigh)
|
|
|
|
Opcode = SystemZ::RISBLH;
|
|
|
|
else {
|
2017-03-22 14:03:32 +08:00
|
|
|
return BuildMI(MBB, MBBI, DL, get(LowLowOpcode), DestReg)
|
2017-01-18 16:32:54 +08:00
|
|
|
.addReg(SrcReg, getKillRegState(KillSrc) | getUndefRegState(UndefSrc));
|
2013-10-01 19:26:28 +08:00
|
|
|
}
|
|
|
|
unsigned Rotate = (DestIsHigh != SrcIsHigh ? 32 : 0);
|
2017-03-22 14:03:32 +08:00
|
|
|
return BuildMI(MBB, MBBI, DL, get(Opcode), DestReg)
|
2013-10-01 19:26:28 +08:00
|
|
|
.addReg(DestReg, RegState::Undef)
|
2017-01-18 16:32:54 +08:00
|
|
|
.addReg(SrcReg, getKillRegState(KillSrc) | getUndefRegState(UndefSrc))
|
2013-10-01 19:26:28 +08:00
|
|
|
.addImm(32 - Size).addImm(128 + 31).addImm(Rotate);
|
|
|
|
}
|
|
|
|
|
2016-11-28 21:34:08 +08:00
|
|
|
MachineInstr *SystemZInstrInfo::commuteInstructionImpl(MachineInstr &MI,
|
|
|
|
bool NewMI,
|
|
|
|
unsigned OpIdx1,
|
|
|
|
unsigned OpIdx2) const {
|
|
|
|
auto cloneIfNew = [NewMI](MachineInstr &MI) -> MachineInstr & {
|
|
|
|
if (NewMI)
|
|
|
|
return *MI.getParent()->getParent()->CloneMachineInstr(&MI);
|
|
|
|
return MI;
|
|
|
|
};
|
|
|
|
|
|
|
|
switch (MI.getOpcode()) {
|
|
|
|
case SystemZ::LOCRMux:
|
|
|
|
case SystemZ::LOCFHR:
|
|
|
|
case SystemZ::LOCR:
|
|
|
|
case SystemZ::LOCGR: {
|
|
|
|
auto &WorkingMI = cloneIfNew(MI);
|
|
|
|
// Invert condition.
|
|
|
|
unsigned CCValid = WorkingMI.getOperand(3).getImm();
|
|
|
|
unsigned CCMask = WorkingMI.getOperand(4).getImm();
|
|
|
|
WorkingMI.getOperand(4).setImm(CCMask ^ CCValid);
|
|
|
|
return TargetInstrInfo::commuteInstructionImpl(WorkingMI, /*NewMI=*/false,
|
|
|
|
OpIdx1, OpIdx2);
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return TargetInstrInfo::commuteInstructionImpl(MI, NewMI, OpIdx1, OpIdx2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
// If MI is a simple load or store for a frame object, return the register
|
|
|
|
// it loads or stores and set FrameIndex to the index of the frame object.
|
|
|
|
// Return 0 otherwise.
|
|
|
|
//
|
|
|
|
// Flag is SimpleBDXLoad for loads and SimpleBDXStore for stores.
|
2016-06-30 08:01:54 +08:00
|
|
|
static int isSimpleMove(const MachineInstr &MI, int &FrameIndex,
|
2013-07-02 23:28:56 +08:00
|
|
|
unsigned Flag) {
|
2016-06-30 08:01:54 +08:00
|
|
|
const MCInstrDesc &MCID = MI.getDesc();
|
|
|
|
if ((MCID.TSFlags & Flag) && MI.getOperand(1).isFI() &&
|
|
|
|
MI.getOperand(2).getImm() == 0 && MI.getOperand(3).getReg() == 0) {
|
|
|
|
FrameIndex = MI.getOperand(1).getIndex();
|
|
|
|
return MI.getOperand(0).getReg();
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
unsigned SystemZInstrInfo::isLoadFromStackSlot(const MachineInstr &MI,
|
2013-05-07 00:15:19 +08:00
|
|
|
int &FrameIndex) const {
|
|
|
|
return isSimpleMove(MI, FrameIndex, SystemZII::SimpleBDXLoad);
|
|
|
|
}
|
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
unsigned SystemZInstrInfo::isStoreToStackSlot(const MachineInstr &MI,
|
2013-05-07 00:15:19 +08:00
|
|
|
int &FrameIndex) const {
|
|
|
|
return isSimpleMove(MI, FrameIndex, SystemZII::SimpleBDXStore);
|
|
|
|
}
|
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
bool SystemZInstrInfo::isStackSlotCopy(const MachineInstr &MI,
|
2013-07-05 22:38:48 +08:00
|
|
|
int &DestFrameIndex,
|
|
|
|
int &SrcFrameIndex) const {
|
|
|
|
// Check for MVC 0(Length,FI1),0(FI2)
|
2016-07-29 02:40:00 +08:00
|
|
|
const MachineFrameInfo &MFI = MI.getParent()->getParent()->getFrameInfo();
|
2016-06-30 08:01:54 +08:00
|
|
|
if (MI.getOpcode() != SystemZ::MVC || !MI.getOperand(0).isFI() ||
|
|
|
|
MI.getOperand(1).getImm() != 0 || !MI.getOperand(3).isFI() ||
|
|
|
|
MI.getOperand(4).getImm() != 0)
|
2013-07-05 22:38:48 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// Check that Length covers the full slots.
|
2016-06-30 08:01:54 +08:00
|
|
|
int64_t Length = MI.getOperand(2).getImm();
|
|
|
|
unsigned FI1 = MI.getOperand(0).getIndex();
|
|
|
|
unsigned FI2 = MI.getOperand(3).getIndex();
|
2016-07-29 02:40:00 +08:00
|
|
|
if (MFI.getObjectSize(FI1) != Length ||
|
|
|
|
MFI.getObjectSize(FI2) != Length)
|
2013-07-05 22:38:48 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
DestFrameIndex = FI1;
|
|
|
|
SrcFrameIndex = FI2;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-07-15 22:41:04 +08:00
|
|
|
bool SystemZInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
|
2013-05-07 00:15:19 +08:00
|
|
|
MachineBasicBlock *&TBB,
|
|
|
|
MachineBasicBlock *&FBB,
|
|
|
|
SmallVectorImpl<MachineOperand> &Cond,
|
|
|
|
bool AllowModify) const {
|
|
|
|
// Most of the code and comments here are boilerplate.
|
|
|
|
|
|
|
|
// Start from the bottom of the block and work up, examining the
|
|
|
|
// terminator instructions.
|
|
|
|
MachineBasicBlock::iterator I = MBB.end();
|
|
|
|
while (I != MBB.begin()) {
|
|
|
|
--I;
|
|
|
|
if (I->isDebugValue())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Working from the bottom, when we see a non-terminator instruction, we're
|
|
|
|
// done.
|
2016-02-23 10:46:52 +08:00
|
|
|
if (!isUnpredicatedTerminator(*I))
|
2013-05-07 00:15:19 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
// A terminator that isn't a branch can't easily be handled by this
|
|
|
|
// analysis.
|
2013-05-28 18:13:54 +08:00
|
|
|
if (!I->isBranch())
|
2013-05-07 00:15:19 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// Can't handle indirect branches.
|
2016-06-30 08:01:54 +08:00
|
|
|
SystemZII::Branch Branch(getBranchInfo(*I));
|
2013-05-28 18:13:54 +08:00
|
|
|
if (!Branch.Target->isMBB())
|
2013-05-07 00:15:19 +08:00
|
|
|
return true;
|
|
|
|
|
2013-05-28 18:41:11 +08:00
|
|
|
// Punt on compound branches.
|
|
|
|
if (Branch.Type != SystemZII::BranchNormal)
|
|
|
|
return true;
|
|
|
|
|
2013-05-28 18:13:54 +08:00
|
|
|
if (Branch.CCMask == SystemZ::CCMASK_ANY) {
|
2013-05-07 00:15:19 +08:00
|
|
|
// Handle unconditional branches.
|
|
|
|
if (!AllowModify) {
|
2013-05-28 18:13:54 +08:00
|
|
|
TBB = Branch.Target->getMBB();
|
2013-05-07 00:15:19 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the block has any instructions after a JMP, delete them.
|
2014-03-02 20:27:27 +08:00
|
|
|
while (std::next(I) != MBB.end())
|
|
|
|
std::next(I)->eraseFromParent();
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
Cond.clear();
|
2014-04-25 13:30:21 +08:00
|
|
|
FBB = nullptr;
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
// Delete the JMP if it's equivalent to a fall-through.
|
2013-05-28 18:13:54 +08:00
|
|
|
if (MBB.isLayoutSuccessor(Branch.Target->getMBB())) {
|
2014-04-25 13:30:21 +08:00
|
|
|
TBB = nullptr;
|
2013-05-07 00:15:19 +08:00
|
|
|
I->eraseFromParent();
|
|
|
|
I = MBB.end();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TBB is used to indicate the unconditinal destination.
|
2013-05-28 18:13:54 +08:00
|
|
|
TBB = Branch.Target->getMBB();
|
2013-05-07 00:15:19 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Working from the bottom, handle the first conditional branch.
|
|
|
|
if (Cond.empty()) {
|
|
|
|
// FIXME: add X86-style branch swap
|
|
|
|
FBB = TBB;
|
2013-05-28 18:13:54 +08:00
|
|
|
TBB = Branch.Target->getMBB();
|
[SystemZ] Be more careful about inverting CC masks
System z branches have a mask to select which of the 4 CC values should
cause the branch to be taken. We can invert a branch by inverting the mask.
However, not all instructions can produce all 4 CC values, so inverting
the branch like this can lead to some oddities. For example, integer
comparisons only produce a CC of 0 (equal), 1 (less) or 2 (greater).
If an integer EQ is reversed to NE before instruction selection,
the branch will test for 1 or 2. If instead the branch is reversed
after instruction selection (by inverting the mask), it will test for
1, 2 or 3. Both are correct, but the second isn't really canonical.
This patch therefore keeps track of which CC values are possible
and uses this when inverting a mask.
Although this is mostly cosmestic, it fixes undefined behavior
for the CIJNLH in branch-08.ll. Another fix would have been
to mask out bit 0 when generating the fused compare and branch,
but the point of this patch is that we shouldn't need to do that
in the first place.
The patch also makes it easier to reuse CC results from other instructions.
llvm-svn: 187495
2013-07-31 20:30:20 +08:00
|
|
|
Cond.push_back(MachineOperand::CreateImm(Branch.CCValid));
|
2013-05-28 18:13:54 +08:00
|
|
|
Cond.push_back(MachineOperand::CreateImm(Branch.CCMask));
|
2013-05-07 00:15:19 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle subsequent conditional branches.
|
[SystemZ] Be more careful about inverting CC masks
System z branches have a mask to select which of the 4 CC values should
cause the branch to be taken. We can invert a branch by inverting the mask.
However, not all instructions can produce all 4 CC values, so inverting
the branch like this can lead to some oddities. For example, integer
comparisons only produce a CC of 0 (equal), 1 (less) or 2 (greater).
If an integer EQ is reversed to NE before instruction selection,
the branch will test for 1 or 2. If instead the branch is reversed
after instruction selection (by inverting the mask), it will test for
1, 2 or 3. Both are correct, but the second isn't really canonical.
This patch therefore keeps track of which CC values are possible
and uses this when inverting a mask.
Although this is mostly cosmestic, it fixes undefined behavior
for the CIJNLH in branch-08.ll. Another fix would have been
to mask out bit 0 when generating the fused compare and branch,
but the point of this patch is that we shouldn't need to do that
in the first place.
The patch also makes it easier to reuse CC results from other instructions.
llvm-svn: 187495
2013-07-31 20:30:20 +08:00
|
|
|
assert(Cond.size() == 2 && TBB && "Should have seen a conditional branch");
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
// Only handle the case where all conditional branches branch to the same
|
|
|
|
// destination.
|
2013-05-28 18:13:54 +08:00
|
|
|
if (TBB != Branch.Target->getMBB())
|
2013-05-07 00:15:19 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// If the conditions are the same, we can leave them alone.
|
[SystemZ] Be more careful about inverting CC masks
System z branches have a mask to select which of the 4 CC values should
cause the branch to be taken. We can invert a branch by inverting the mask.
However, not all instructions can produce all 4 CC values, so inverting
the branch like this can lead to some oddities. For example, integer
comparisons only produce a CC of 0 (equal), 1 (less) or 2 (greater).
If an integer EQ is reversed to NE before instruction selection,
the branch will test for 1 or 2. If instead the branch is reversed
after instruction selection (by inverting the mask), it will test for
1, 2 or 3. Both are correct, but the second isn't really canonical.
This patch therefore keeps track of which CC values are possible
and uses this when inverting a mask.
Although this is mostly cosmestic, it fixes undefined behavior
for the CIJNLH in branch-08.ll. Another fix would have been
to mask out bit 0 when generating the fused compare and branch,
but the point of this patch is that we shouldn't need to do that
in the first place.
The patch also makes it easier to reuse CC results from other instructions.
llvm-svn: 187495
2013-07-31 20:30:20 +08:00
|
|
|
unsigned OldCCValid = Cond[0].getImm();
|
|
|
|
unsigned OldCCMask = Cond[1].getImm();
|
|
|
|
if (OldCCValid == Branch.CCValid && OldCCMask == Branch.CCMask)
|
2013-05-07 00:15:19 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// FIXME: Try combining conditions like X86 does. Should be easy on Z!
|
[SystemZ] Be more careful about inverting CC masks
System z branches have a mask to select which of the 4 CC values should
cause the branch to be taken. We can invert a branch by inverting the mask.
However, not all instructions can produce all 4 CC values, so inverting
the branch like this can lead to some oddities. For example, integer
comparisons only produce a CC of 0 (equal), 1 (less) or 2 (greater).
If an integer EQ is reversed to NE before instruction selection,
the branch will test for 1 or 2. If instead the branch is reversed
after instruction selection (by inverting the mask), it will test for
1, 2 or 3. Both are correct, but the second isn't really canonical.
This patch therefore keeps track of which CC values are possible
and uses this when inverting a mask.
Although this is mostly cosmestic, it fixes undefined behavior
for the CIJNLH in branch-08.ll. Another fix would have been
to mask out bit 0 when generating the fused compare and branch,
but the point of this patch is that we shouldn't need to do that
in the first place.
The patch also makes it easier to reuse CC results from other instructions.
llvm-svn: 187495
2013-07-31 20:30:20 +08:00
|
|
|
return false;
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-09-15 04:43:16 +08:00
|
|
|
unsigned SystemZInstrInfo::removeBranch(MachineBasicBlock &MBB,
|
2016-09-15 01:23:48 +08:00
|
|
|
int *BytesRemoved) const {
|
|
|
|
assert(!BytesRemoved && "code size not handled");
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
// Most of the code and comments here are boilerplate.
|
|
|
|
MachineBasicBlock::iterator I = MBB.end();
|
|
|
|
unsigned Count = 0;
|
|
|
|
|
|
|
|
while (I != MBB.begin()) {
|
|
|
|
--I;
|
|
|
|
if (I->isDebugValue())
|
|
|
|
continue;
|
2013-05-28 18:13:54 +08:00
|
|
|
if (!I->isBranch())
|
2013-05-07 00:15:19 +08:00
|
|
|
break;
|
2016-06-30 08:01:54 +08:00
|
|
|
if (!getBranchInfo(*I).Target->isMBB())
|
2013-05-07 00:15:19 +08:00
|
|
|
break;
|
|
|
|
// Remove the branch.
|
|
|
|
I->eraseFromParent();
|
|
|
|
I = MBB.end();
|
|
|
|
++Count;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Count;
|
|
|
|
}
|
|
|
|
|
[SystemZ] Be more careful about inverting CC masks
System z branches have a mask to select which of the 4 CC values should
cause the branch to be taken. We can invert a branch by inverting the mask.
However, not all instructions can produce all 4 CC values, so inverting
the branch like this can lead to some oddities. For example, integer
comparisons only produce a CC of 0 (equal), 1 (less) or 2 (greater).
If an integer EQ is reversed to NE before instruction selection,
the branch will test for 1 or 2. If instead the branch is reversed
after instruction selection (by inverting the mask), it will test for
1, 2 or 3. Both are correct, but the second isn't really canonical.
This patch therefore keeps track of which CC values are possible
and uses this when inverting a mask.
Although this is mostly cosmestic, it fixes undefined behavior
for the CIJNLH in branch-08.ll. Another fix would have been
to mask out bit 0 when generating the fused compare and branch,
but the point of this patch is that we shouldn't need to do that
in the first place.
The patch also makes it easier to reuse CC results from other instructions.
llvm-svn: 187495
2013-07-31 20:30:20 +08:00
|
|
|
bool SystemZInstrInfo::
|
2016-09-15 04:43:16 +08:00
|
|
|
reverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const {
|
[SystemZ] Be more careful about inverting CC masks
System z branches have a mask to select which of the 4 CC values should
cause the branch to be taken. We can invert a branch by inverting the mask.
However, not all instructions can produce all 4 CC values, so inverting
the branch like this can lead to some oddities. For example, integer
comparisons only produce a CC of 0 (equal), 1 (less) or 2 (greater).
If an integer EQ is reversed to NE before instruction selection,
the branch will test for 1 or 2. If instead the branch is reversed
after instruction selection (by inverting the mask), it will test for
1, 2 or 3. Both are correct, but the second isn't really canonical.
This patch therefore keeps track of which CC values are possible
and uses this when inverting a mask.
Although this is mostly cosmestic, it fixes undefined behavior
for the CIJNLH in branch-08.ll. Another fix would have been
to mask out bit 0 when generating the fused compare and branch,
but the point of this patch is that we shouldn't need to do that
in the first place.
The patch also makes it easier to reuse CC results from other instructions.
llvm-svn: 187495
2013-07-31 20:30:20 +08:00
|
|
|
assert(Cond.size() == 2 && "Invalid condition");
|
|
|
|
Cond[1].setImm(Cond[1].getImm() ^ Cond[0].getImm());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-09-15 01:24:15 +08:00
|
|
|
unsigned SystemZInstrInfo::insertBranch(MachineBasicBlock &MBB,
|
2016-06-12 23:39:02 +08:00
|
|
|
MachineBasicBlock *TBB,
|
|
|
|
MachineBasicBlock *FBB,
|
|
|
|
ArrayRef<MachineOperand> Cond,
|
2016-09-15 01:23:48 +08:00
|
|
|
const DebugLoc &DL,
|
|
|
|
int *BytesAdded) const {
|
2013-05-07 00:15:19 +08:00
|
|
|
// In this function we output 32-bit branches, which should always
|
|
|
|
// have enough range. They can be shortened and relaxed by later code
|
|
|
|
// in the pipeline, if desired.
|
|
|
|
|
|
|
|
// Shouldn't be a fall through.
|
2016-09-15 01:24:15 +08:00
|
|
|
assert(TBB && "insertBranch must not be told to insert a fallthrough");
|
[SystemZ] Be more careful about inverting CC masks
System z branches have a mask to select which of the 4 CC values should
cause the branch to be taken. We can invert a branch by inverting the mask.
However, not all instructions can produce all 4 CC values, so inverting
the branch like this can lead to some oddities. For example, integer
comparisons only produce a CC of 0 (equal), 1 (less) or 2 (greater).
If an integer EQ is reversed to NE before instruction selection,
the branch will test for 1 or 2. If instead the branch is reversed
after instruction selection (by inverting the mask), it will test for
1, 2 or 3. Both are correct, but the second isn't really canonical.
This patch therefore keeps track of which CC values are possible
and uses this when inverting a mask.
Although this is mostly cosmestic, it fixes undefined behavior
for the CIJNLH in branch-08.ll. Another fix would have been
to mask out bit 0 when generating the fused compare and branch,
but the point of this patch is that we shouldn't need to do that
in the first place.
The patch also makes it easier to reuse CC results from other instructions.
llvm-svn: 187495
2013-07-31 20:30:20 +08:00
|
|
|
assert((Cond.size() == 2 || Cond.size() == 0) &&
|
2013-05-07 00:15:19 +08:00
|
|
|
"SystemZ branch conditions have one component!");
|
2016-09-15 01:23:48 +08:00
|
|
|
assert(!BytesAdded && "code size not handled");
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
if (Cond.empty()) {
|
|
|
|
// Unconditional branch?
|
|
|
|
assert(!FBB && "Unconditional branch with multiple successors!");
|
[SystemZ] Add long branch pass
Before this change, the SystemZ backend would use BRCL for all branches
and only consider shortening them to BRC when generating an object file.
E.g. a branch on equal would use the JGE alias of BRCL in assembly output,
but might be shortened to the JE alias of BRC in ELF output. This was
a useful first step, but it had two problems:
(1) The z assembler isn't traditionally supposed to perform branch shortening
or branch relaxation. We followed this rule by not relaxing branches
in assembler input, but that meant that generating assembly code and
then assembling it would not produce the same result as going directly
to object code; the former would give long branches everywhere, whereas
the latter would use short branches where possible.
(2) Other useful branches, like COMPARE AND BRANCH, do not have long forms.
We would need to do something else before supporting them.
(Although COMPARE AND BRANCH does not change the condition codes,
the plan is to model COMPARE AND BRANCH as a CC-clobbering instruction
during codegen, so that we can safely lower it to a separate compare
and long branch where necessary. This is not a valid transformation
for the assembler proper to make.)
This patch therefore moves branch relaxation to a pre-emit pass.
For now, calls are still shortened from BRASL to BRAS by the assembler,
although this too is not really the traditional behaviour.
The first test takes about 1.5s to run, and there are likely to be
more tests in this vein once further branch types are added. The feeling
on IRC was that 1.5s is a bit much for a single test, so I've restricted
it to SystemZ hosts for now.
The patch exposes (and fixes) some typos in the main CodeGen/SystemZ tests.
A later patch will remove the {{g}}s from that directory.
llvm-svn: 182274
2013-05-20 22:23:08 +08:00
|
|
|
BuildMI(&MBB, DL, get(SystemZ::J)).addMBB(TBB);
|
2013-05-07 00:15:19 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Conditional branch.
|
|
|
|
unsigned Count = 0;
|
[SystemZ] Be more careful about inverting CC masks
System z branches have a mask to select which of the 4 CC values should
cause the branch to be taken. We can invert a branch by inverting the mask.
However, not all instructions can produce all 4 CC values, so inverting
the branch like this can lead to some oddities. For example, integer
comparisons only produce a CC of 0 (equal), 1 (less) or 2 (greater).
If an integer EQ is reversed to NE before instruction selection,
the branch will test for 1 or 2. If instead the branch is reversed
after instruction selection (by inverting the mask), it will test for
1, 2 or 3. Both are correct, but the second isn't really canonical.
This patch therefore keeps track of which CC values are possible
and uses this when inverting a mask.
Although this is mostly cosmestic, it fixes undefined behavior
for the CIJNLH in branch-08.ll. Another fix would have been
to mask out bit 0 when generating the fused compare and branch,
but the point of this patch is that we shouldn't need to do that
in the first place.
The patch also makes it easier to reuse CC results from other instructions.
llvm-svn: 187495
2013-07-31 20:30:20 +08:00
|
|
|
unsigned CCValid = Cond[0].getImm();
|
|
|
|
unsigned CCMask = Cond[1].getImm();
|
|
|
|
BuildMI(&MBB, DL, get(SystemZ::BRC))
|
|
|
|
.addImm(CCValid).addImm(CCMask).addMBB(TBB);
|
2013-05-07 00:15:19 +08:00
|
|
|
++Count;
|
|
|
|
|
|
|
|
if (FBB) {
|
|
|
|
// Two-way Conditional branch. Insert the second branch.
|
[SystemZ] Add long branch pass
Before this change, the SystemZ backend would use BRCL for all branches
and only consider shortening them to BRC when generating an object file.
E.g. a branch on equal would use the JGE alias of BRCL in assembly output,
but might be shortened to the JE alias of BRC in ELF output. This was
a useful first step, but it had two problems:
(1) The z assembler isn't traditionally supposed to perform branch shortening
or branch relaxation. We followed this rule by not relaxing branches
in assembler input, but that meant that generating assembly code and
then assembling it would not produce the same result as going directly
to object code; the former would give long branches everywhere, whereas
the latter would use short branches where possible.
(2) Other useful branches, like COMPARE AND BRANCH, do not have long forms.
We would need to do something else before supporting them.
(Although COMPARE AND BRANCH does not change the condition codes,
the plan is to model COMPARE AND BRANCH as a CC-clobbering instruction
during codegen, so that we can safely lower it to a separate compare
and long branch where necessary. This is not a valid transformation
for the assembler proper to make.)
This patch therefore moves branch relaxation to a pre-emit pass.
For now, calls are still shortened from BRASL to BRAS by the assembler,
although this too is not really the traditional behaviour.
The first test takes about 1.5s to run, and there are likely to be
more tests in this vein once further branch types are added. The feeling
on IRC was that 1.5s is a bit much for a single test, so I've restricted
it to SystemZ hosts for now.
The patch exposes (and fixes) some typos in the main CodeGen/SystemZ tests.
A later patch will remove the {{g}}s from that directory.
llvm-svn: 182274
2013-05-20 22:23:08 +08:00
|
|
|
BuildMI(&MBB, DL, get(SystemZ::J)).addMBB(FBB);
|
2013-05-07 00:15:19 +08:00
|
|
|
++Count;
|
|
|
|
}
|
|
|
|
return Count;
|
|
|
|
}
|
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
bool SystemZInstrInfo::analyzeCompare(const MachineInstr &MI, unsigned &SrcReg,
|
|
|
|
unsigned &SrcReg2, int &Mask,
|
|
|
|
int &Value) const {
|
|
|
|
assert(MI.isCompare() && "Caller should have checked for a comparison");
|
2013-08-12 18:28:10 +08:00
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
if (MI.getNumExplicitOperands() == 2 && MI.getOperand(0).isReg() &&
|
|
|
|
MI.getOperand(1).isImm()) {
|
|
|
|
SrcReg = MI.getOperand(0).getReg();
|
2013-08-12 18:28:10 +08:00
|
|
|
SrcReg2 = 0;
|
2016-06-30 08:01:54 +08:00
|
|
|
Value = MI.getOperand(1).getImm();
|
2013-08-12 18:28:10 +08:00
|
|
|
Mask = ~0;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
[SystemZ] Fix sign of integer memcmp result
r188163 used CLC to implement memcmp. Code that compares the result
directly against zero can test the CC value produced by CLC, but code
that needs an integer result must use IPM. The sequence I'd used was:
ipm <reg>
sll <reg>, 2
sra <reg>, 30
but I'd forgotten that this inverts the order, so that CC==1 ("less")
becomes an integer greater than zero, and CC==2 ("greater") becomes
an integer less than zero. This sequence should only be used if the
CLC arguments are reversed to compensate. The problem then is that
the branch condition must also be reversed when testing the CLC
result directly.
Rather than do that, I went for a different sequence that works with
the natural CLC order:
ipm <reg>
srl <reg>, 28
rll <reg>, <reg>, 31
One advantage of this is that it doesn't clobber CC. A disadvantage
is that any sign extension to 64 bits must be done separately,
rather than being folded into the shifts.
llvm-svn: 188538
2013-08-16 18:22:54 +08:00
|
|
|
// If Reg is a virtual register, return its definition, otherwise return null.
|
|
|
|
static MachineInstr *getDef(unsigned Reg,
|
|
|
|
const MachineRegisterInfo *MRI) {
|
2013-08-12 18:28:10 +08:00
|
|
|
if (TargetRegisterInfo::isPhysicalRegister(Reg))
|
2014-04-25 13:30:21 +08:00
|
|
|
return nullptr;
|
2013-08-12 18:28:10 +08:00
|
|
|
return MRI->getUniqueVRegDef(Reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return true if MI is a shift of type Opcode by Imm bits.
|
2015-05-19 04:27:55 +08:00
|
|
|
static bool isShift(MachineInstr *MI, unsigned Opcode, int64_t Imm) {
|
2013-08-12 18:28:10 +08:00
|
|
|
return (MI->getOpcode() == Opcode &&
|
|
|
|
!MI->getOperand(2).getReg() &&
|
|
|
|
MI->getOperand(3).getImm() == Imm);
|
|
|
|
}
|
|
|
|
|
[SystemZ] Fix sign of integer memcmp result
r188163 used CLC to implement memcmp. Code that compares the result
directly against zero can test the CC value produced by CLC, but code
that needs an integer result must use IPM. The sequence I'd used was:
ipm <reg>
sll <reg>, 2
sra <reg>, 30
but I'd forgotten that this inverts the order, so that CC==1 ("less")
becomes an integer greater than zero, and CC==2 ("greater") becomes
an integer less than zero. This sequence should only be used if the
CLC arguments are reversed to compensate. The problem then is that
the branch condition must also be reversed when testing the CLC
result directly.
Rather than do that, I went for a different sequence that works with
the natural CLC order:
ipm <reg>
srl <reg>, 28
rll <reg>, <reg>, 31
One advantage of this is that it doesn't clobber CC. A disadvantage
is that any sign extension to 64 bits must be done separately,
rather than being folded into the shifts.
llvm-svn: 188538
2013-08-16 18:22:54 +08:00
|
|
|
// If the destination of MI has no uses, delete it as dead.
|
|
|
|
static void eraseIfDead(MachineInstr *MI, const MachineRegisterInfo *MRI) {
|
|
|
|
if (MRI->use_nodbg_empty(MI->getOperand(0).getReg()))
|
|
|
|
MI->eraseFromParent();
|
|
|
|
}
|
|
|
|
|
2013-08-12 18:28:10 +08:00
|
|
|
// Compare compares SrcReg against zero. Check whether SrcReg contains
|
[SystemZ] Fix sign of integer memcmp result
r188163 used CLC to implement memcmp. Code that compares the result
directly against zero can test the CC value produced by CLC, but code
that needs an integer result must use IPM. The sequence I'd used was:
ipm <reg>
sll <reg>, 2
sra <reg>, 30
but I'd forgotten that this inverts the order, so that CC==1 ("less")
becomes an integer greater than zero, and CC==2 ("greater") becomes
an integer less than zero. This sequence should only be used if the
CLC arguments are reversed to compensate. The problem then is that
the branch condition must also be reversed when testing the CLC
result directly.
Rather than do that, I went for a different sequence that works with
the natural CLC order:
ipm <reg>
srl <reg>, 28
rll <reg>, <reg>, 31
One advantage of this is that it doesn't clobber CC. A disadvantage
is that any sign extension to 64 bits must be done separately,
rather than being folded into the shifts.
llvm-svn: 188538
2013-08-16 18:22:54 +08:00
|
|
|
// the result of an IPM sequence whose input CC survives until Compare,
|
|
|
|
// and whether Compare is therefore redundant. Delete it and return
|
|
|
|
// true if so.
|
2016-06-30 08:01:54 +08:00
|
|
|
static bool removeIPMBasedCompare(MachineInstr &Compare, unsigned SrcReg,
|
[SystemZ] Fix sign of integer memcmp result
r188163 used CLC to implement memcmp. Code that compares the result
directly against zero can test the CC value produced by CLC, but code
that needs an integer result must use IPM. The sequence I'd used was:
ipm <reg>
sll <reg>, 2
sra <reg>, 30
but I'd forgotten that this inverts the order, so that CC==1 ("less")
becomes an integer greater than zero, and CC==2 ("greater") becomes
an integer less than zero. This sequence should only be used if the
CLC arguments are reversed to compensate. The problem then is that
the branch condition must also be reversed when testing the CLC
result directly.
Rather than do that, I went for a different sequence that works with
the natural CLC order:
ipm <reg>
srl <reg>, 28
rll <reg>, <reg>, 31
One advantage of this is that it doesn't clobber CC. A disadvantage
is that any sign extension to 64 bits must be done separately,
rather than being folded into the shifts.
llvm-svn: 188538
2013-08-16 18:22:54 +08:00
|
|
|
const MachineRegisterInfo *MRI,
|
|
|
|
const TargetRegisterInfo *TRI) {
|
2014-04-25 13:30:21 +08:00
|
|
|
MachineInstr *LGFR = nullptr;
|
[SystemZ] Fix sign of integer memcmp result
r188163 used CLC to implement memcmp. Code that compares the result
directly against zero can test the CC value produced by CLC, but code
that needs an integer result must use IPM. The sequence I'd used was:
ipm <reg>
sll <reg>, 2
sra <reg>, 30
but I'd forgotten that this inverts the order, so that CC==1 ("less")
becomes an integer greater than zero, and CC==2 ("greater") becomes
an integer less than zero. This sequence should only be used if the
CLC arguments are reversed to compensate. The problem then is that
the branch condition must also be reversed when testing the CLC
result directly.
Rather than do that, I went for a different sequence that works with
the natural CLC order:
ipm <reg>
srl <reg>, 28
rll <reg>, <reg>, 31
One advantage of this is that it doesn't clobber CC. A disadvantage
is that any sign extension to 64 bits must be done separately,
rather than being folded into the shifts.
llvm-svn: 188538
2013-08-16 18:22:54 +08:00
|
|
|
MachineInstr *RLL = getDef(SrcReg, MRI);
|
2013-08-16 18:55:47 +08:00
|
|
|
if (RLL && RLL->getOpcode() == SystemZ::LGFR) {
|
|
|
|
LGFR = RLL;
|
|
|
|
RLL = getDef(LGFR->getOperand(1).getReg(), MRI);
|
|
|
|
}
|
[SystemZ] Fix sign of integer memcmp result
r188163 used CLC to implement memcmp. Code that compares the result
directly against zero can test the CC value produced by CLC, but code
that needs an integer result must use IPM. The sequence I'd used was:
ipm <reg>
sll <reg>, 2
sra <reg>, 30
but I'd forgotten that this inverts the order, so that CC==1 ("less")
becomes an integer greater than zero, and CC==2 ("greater") becomes
an integer less than zero. This sequence should only be used if the
CLC arguments are reversed to compensate. The problem then is that
the branch condition must also be reversed when testing the CLC
result directly.
Rather than do that, I went for a different sequence that works with
the natural CLC order:
ipm <reg>
srl <reg>, 28
rll <reg>, <reg>, 31
One advantage of this is that it doesn't clobber CC. A disadvantage
is that any sign extension to 64 bits must be done separately,
rather than being folded into the shifts.
llvm-svn: 188538
2013-08-16 18:22:54 +08:00
|
|
|
if (!RLL || !isShift(RLL, SystemZ::RLL, 31))
|
2013-08-12 18:28:10 +08:00
|
|
|
return false;
|
|
|
|
|
[SystemZ] Fix sign of integer memcmp result
r188163 used CLC to implement memcmp. Code that compares the result
directly against zero can test the CC value produced by CLC, but code
that needs an integer result must use IPM. The sequence I'd used was:
ipm <reg>
sll <reg>, 2
sra <reg>, 30
but I'd forgotten that this inverts the order, so that CC==1 ("less")
becomes an integer greater than zero, and CC==2 ("greater") becomes
an integer less than zero. This sequence should only be used if the
CLC arguments are reversed to compensate. The problem then is that
the branch condition must also be reversed when testing the CLC
result directly.
Rather than do that, I went for a different sequence that works with
the natural CLC order:
ipm <reg>
srl <reg>, 28
rll <reg>, <reg>, 31
One advantage of this is that it doesn't clobber CC. A disadvantage
is that any sign extension to 64 bits must be done separately,
rather than being folded into the shifts.
llvm-svn: 188538
2013-08-16 18:22:54 +08:00
|
|
|
MachineInstr *SRL = getDef(RLL->getOperand(1).getReg(), MRI);
|
2013-10-16 19:10:55 +08:00
|
|
|
if (!SRL || !isShift(SRL, SystemZ::SRL, SystemZ::IPM_CC))
|
2013-08-12 18:28:10 +08:00
|
|
|
return false;
|
|
|
|
|
[SystemZ] Fix sign of integer memcmp result
r188163 used CLC to implement memcmp. Code that compares the result
directly against zero can test the CC value produced by CLC, but code
that needs an integer result must use IPM. The sequence I'd used was:
ipm <reg>
sll <reg>, 2
sra <reg>, 30
but I'd forgotten that this inverts the order, so that CC==1 ("less")
becomes an integer greater than zero, and CC==2 ("greater") becomes
an integer less than zero. This sequence should only be used if the
CLC arguments are reversed to compensate. The problem then is that
the branch condition must also be reversed when testing the CLC
result directly.
Rather than do that, I went for a different sequence that works with
the natural CLC order:
ipm <reg>
srl <reg>, 28
rll <reg>, <reg>, 31
One advantage of this is that it doesn't clobber CC. A disadvantage
is that any sign extension to 64 bits must be done separately,
rather than being folded into the shifts.
llvm-svn: 188538
2013-08-16 18:22:54 +08:00
|
|
|
MachineInstr *IPM = getDef(SRL->getOperand(1).getReg(), MRI);
|
2013-08-12 18:28:10 +08:00
|
|
|
if (!IPM || IPM->getOpcode() != SystemZ::IPM)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Check that there are no assignments to CC between the IPM and Compare,
|
2016-06-30 08:01:54 +08:00
|
|
|
if (IPM->getParent() != Compare.getParent())
|
2013-08-12 18:28:10 +08:00
|
|
|
return false;
|
2016-06-30 08:01:54 +08:00
|
|
|
MachineBasicBlock::iterator MBBI = IPM, MBBE = Compare.getIterator();
|
2013-08-12 18:28:10 +08:00
|
|
|
for (++MBBI; MBBI != MBBE; ++MBBI) {
|
2016-07-12 09:39:01 +08:00
|
|
|
MachineInstr &MI = *MBBI;
|
|
|
|
if (MI.modifiesRegister(SystemZ::CC, TRI))
|
2013-08-12 18:28:10 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
Compare.eraseFromParent();
|
2013-08-16 18:55:47 +08:00
|
|
|
if (LGFR)
|
|
|
|
eraseIfDead(LGFR, MRI);
|
[SystemZ] Fix sign of integer memcmp result
r188163 used CLC to implement memcmp. Code that compares the result
directly against zero can test the CC value produced by CLC, but code
that needs an integer result must use IPM. The sequence I'd used was:
ipm <reg>
sll <reg>, 2
sra <reg>, 30
but I'd forgotten that this inverts the order, so that CC==1 ("less")
becomes an integer greater than zero, and CC==2 ("greater") becomes
an integer less than zero. This sequence should only be used if the
CLC arguments are reversed to compensate. The problem then is that
the branch condition must also be reversed when testing the CLC
result directly.
Rather than do that, I went for a different sequence that works with
the natural CLC order:
ipm <reg>
srl <reg>, 28
rll <reg>, <reg>, 31
One advantage of this is that it doesn't clobber CC. A disadvantage
is that any sign extension to 64 bits must be done separately,
rather than being folded into the shifts.
llvm-svn: 188538
2013-08-16 18:22:54 +08:00
|
|
|
eraseIfDead(RLL, MRI);
|
|
|
|
eraseIfDead(SRL, MRI);
|
|
|
|
eraseIfDead(IPM, MRI);
|
|
|
|
|
2013-08-12 18:28:10 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
bool SystemZInstrInfo::optimizeCompareInstr(
|
|
|
|
MachineInstr &Compare, unsigned SrcReg, unsigned SrcReg2, int Mask,
|
|
|
|
int Value, const MachineRegisterInfo *MRI) const {
|
2013-08-12 18:28:10 +08:00
|
|
|
assert(!SrcReg2 && "Only optimizing constant comparisons so far");
|
2016-06-30 08:01:54 +08:00
|
|
|
bool IsLogical = (Compare.getDesc().TSFlags & SystemZII::IsLogical) != 0;
|
2015-11-13 21:00:27 +08:00
|
|
|
return Value == 0 && !IsLogical &&
|
|
|
|
removeIPMBasedCompare(Compare, SrcReg, MRI, &RI);
|
2013-08-12 18:28:10 +08:00
|
|
|
}
|
|
|
|
|
2016-11-28 21:34:08 +08:00
|
|
|
bool SystemZInstrInfo::canInsertSelect(const MachineBasicBlock &MBB,
|
|
|
|
ArrayRef<MachineOperand> Pred,
|
|
|
|
unsigned TrueReg, unsigned FalseReg,
|
|
|
|
int &CondCycles, int &TrueCycles,
|
|
|
|
int &FalseCycles) const {
|
|
|
|
// Not all subtargets have LOCR instructions.
|
|
|
|
if (!STI.hasLoadStoreOnCond())
|
|
|
|
return false;
|
|
|
|
if (Pred.size() != 2)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Check register classes.
|
|
|
|
const MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
|
|
|
|
const TargetRegisterClass *RC =
|
|
|
|
RI.getCommonSubClass(MRI.getRegClass(TrueReg), MRI.getRegClass(FalseReg));
|
|
|
|
if (!RC)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// We have LOCR instructions for 32 and 64 bit general purpose registers.
|
|
|
|
if ((STI.hasLoadStoreOnCond2() &&
|
|
|
|
SystemZ::GRX32BitRegClass.hasSubClassEq(RC)) ||
|
|
|
|
SystemZ::GR32BitRegClass.hasSubClassEq(RC) ||
|
|
|
|
SystemZ::GR64BitRegClass.hasSubClassEq(RC)) {
|
|
|
|
CondCycles = 2;
|
|
|
|
TrueCycles = 2;
|
|
|
|
FalseCycles = 2;
|
|
|
|
return true;
|
2013-07-25 17:11:15 +08:00
|
|
|
}
|
2016-11-28 21:34:08 +08:00
|
|
|
|
|
|
|
// Can't do anything else.
|
|
|
|
return false;
|
2013-07-25 17:11:15 +08:00
|
|
|
}
|
|
|
|
|
2016-11-28 21:34:08 +08:00
|
|
|
void SystemZInstrInfo::insertSelect(MachineBasicBlock &MBB,
|
|
|
|
MachineBasicBlock::iterator I,
|
|
|
|
const DebugLoc &DL, unsigned DstReg,
|
|
|
|
ArrayRef<MachineOperand> Pred,
|
|
|
|
unsigned TrueReg,
|
|
|
|
unsigned FalseReg) const {
|
|
|
|
MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
|
|
|
|
const TargetRegisterClass *RC = MRI.getRegClass(DstReg);
|
|
|
|
|
|
|
|
assert(Pred.size() == 2 && "Invalid condition");
|
|
|
|
unsigned CCValid = Pred[0].getImm();
|
|
|
|
unsigned CCMask = Pred[1].getImm();
|
|
|
|
|
|
|
|
unsigned Opc;
|
|
|
|
if (SystemZ::GRX32BitRegClass.hasSubClassEq(RC)) {
|
|
|
|
if (STI.hasLoadStoreOnCond2())
|
|
|
|
Opc = SystemZ::LOCRMux;
|
|
|
|
else {
|
|
|
|
Opc = SystemZ::LOCR;
|
|
|
|
MRI.constrainRegClass(DstReg, &SystemZ::GR32BitRegClass);
|
2017-03-31 22:06:59 +08:00
|
|
|
unsigned TReg = MRI.createVirtualRegister(&SystemZ::GR32BitRegClass);
|
|
|
|
unsigned FReg = MRI.createVirtualRegister(&SystemZ::GR32BitRegClass);
|
|
|
|
BuildMI(MBB, I, DL, get(TargetOpcode::COPY), TReg).addReg(TrueReg);
|
|
|
|
BuildMI(MBB, I, DL, get(TargetOpcode::COPY), FReg).addReg(FalseReg);
|
|
|
|
TrueReg = TReg;
|
|
|
|
FalseReg = FReg;
|
2016-11-28 21:34:08 +08:00
|
|
|
}
|
|
|
|
} else if (SystemZ::GR64BitRegClass.hasSubClassEq(RC))
|
|
|
|
Opc = SystemZ::LOCGR;
|
|
|
|
else
|
|
|
|
llvm_unreachable("Invalid register class");
|
|
|
|
|
|
|
|
BuildMI(MBB, I, DL, get(Opc), DstReg)
|
|
|
|
.addReg(FalseReg).addReg(TrueReg)
|
|
|
|
.addImm(CCValid).addImm(CCMask);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SystemZInstrInfo::FoldImmediate(MachineInstr &UseMI, MachineInstr &DefMI,
|
|
|
|
unsigned Reg,
|
|
|
|
MachineRegisterInfo *MRI) const {
|
|
|
|
unsigned DefOpc = DefMI.getOpcode();
|
|
|
|
if (DefOpc != SystemZ::LHIMux && DefOpc != SystemZ::LHI &&
|
|
|
|
DefOpc != SystemZ::LGHI)
|
|
|
|
return false;
|
|
|
|
if (DefMI.getOperand(0).getReg() != Reg)
|
|
|
|
return false;
|
|
|
|
int32_t ImmVal = (int32_t)DefMI.getOperand(1).getImm();
|
|
|
|
|
|
|
|
unsigned UseOpc = UseMI.getOpcode();
|
|
|
|
unsigned NewUseOpc;
|
|
|
|
unsigned UseIdx;
|
|
|
|
int CommuteIdx = -1;
|
|
|
|
switch (UseOpc) {
|
|
|
|
case SystemZ::LOCRMux:
|
|
|
|
if (!STI.hasLoadStoreOnCond2())
|
|
|
|
return false;
|
|
|
|
NewUseOpc = SystemZ::LOCHIMux;
|
|
|
|
if (UseMI.getOperand(2).getReg() == Reg)
|
|
|
|
UseIdx = 2;
|
|
|
|
else if (UseMI.getOperand(1).getReg() == Reg)
|
|
|
|
UseIdx = 2, CommuteIdx = 1;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case SystemZ::LOCGR:
|
|
|
|
if (!STI.hasLoadStoreOnCond2())
|
|
|
|
return false;
|
|
|
|
NewUseOpc = SystemZ::LOCGHI;
|
|
|
|
if (UseMI.getOperand(2).getReg() == Reg)
|
|
|
|
UseIdx = 2;
|
|
|
|
else if (UseMI.getOperand(1).getReg() == Reg)
|
|
|
|
UseIdx = 2, CommuteIdx = 1;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return false;
|
2016-07-12 02:45:03 +08:00
|
|
|
}
|
2016-11-28 21:34:08 +08:00
|
|
|
|
|
|
|
if (CommuteIdx != -1)
|
|
|
|
if (!commuteInstruction(UseMI, false, CommuteIdx, UseIdx))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
bool DeleteDef = MRI->hasOneNonDBGUse(Reg);
|
|
|
|
UseMI.setDesc(get(NewUseOpc));
|
|
|
|
UseMI.getOperand(UseIdx).ChangeToImmediate(ImmVal);
|
|
|
|
if (DeleteDef)
|
|
|
|
DefMI.eraseFromParent();
|
|
|
|
|
|
|
|
return true;
|
2016-07-12 02:45:03 +08:00
|
|
|
}
|
|
|
|
|
2017-03-04 02:30:54 +08:00
|
|
|
bool SystemZInstrInfo::isPredicable(const MachineInstr &MI) const {
|
2016-02-23 10:46:52 +08:00
|
|
|
unsigned Opcode = MI.getOpcode();
|
2016-04-09 01:22:19 +08:00
|
|
|
if (Opcode == SystemZ::Return ||
|
2016-06-11 03:58:10 +08:00
|
|
|
Opcode == SystemZ::Trap ||
|
2016-04-11 20:12:32 +08:00
|
|
|
Opcode == SystemZ::CallJG ||
|
|
|
|
Opcode == SystemZ::CallBR)
|
2016-04-08 00:11:44 +08:00
|
|
|
return true;
|
|
|
|
return false;
|
2013-07-25 17:11:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool SystemZInstrInfo::
|
|
|
|
isProfitableToIfCvt(MachineBasicBlock &MBB,
|
|
|
|
unsigned NumCycles, unsigned ExtraPredCycles,
|
2015-09-11 07:10:42 +08:00
|
|
|
BranchProbability Probability) const {
|
2016-04-08 00:11:44 +08:00
|
|
|
// Avoid using conditional returns at the end of a loop (since then
|
|
|
|
// we'd need to emit an unconditional branch to the beginning anyway,
|
|
|
|
// making the loop body longer). This doesn't apply for low-probability
|
|
|
|
// loops (eg. compare-and-swap retry), so just decide based on branch
|
|
|
|
// probability instead of looping structure.
|
2016-06-11 03:58:10 +08:00
|
|
|
// However, since Compare and Trap instructions cost the same as a regular
|
|
|
|
// Compare instruction, we should allow the if conversion to convert this
|
|
|
|
// into a Conditional Compare regardless of the branch probability.
|
|
|
|
if (MBB.getLastNonDebugInstr()->getOpcode() != SystemZ::Trap &&
|
|
|
|
MBB.succ_empty() && Probability < BranchProbability(1, 8))
|
2016-04-08 00:11:44 +08:00
|
|
|
return false;
|
2013-07-25 17:11:15 +08:00
|
|
|
// For now only convert single instructions.
|
|
|
|
return NumCycles == 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SystemZInstrInfo::
|
|
|
|
isProfitableToIfCvt(MachineBasicBlock &TMBB,
|
|
|
|
unsigned NumCyclesT, unsigned ExtraPredCyclesT,
|
|
|
|
MachineBasicBlock &FMBB,
|
|
|
|
unsigned NumCyclesF, unsigned ExtraPredCyclesF,
|
2015-09-11 07:10:42 +08:00
|
|
|
BranchProbability Probability) const {
|
2013-07-25 17:11:15 +08:00
|
|
|
// For now avoid converting mutually-exclusive cases.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-04-08 00:11:44 +08:00
|
|
|
bool SystemZInstrInfo::
|
|
|
|
isProfitableToDupForIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
|
|
|
|
BranchProbability Probability) const {
|
|
|
|
// For now only duplicate single instructions.
|
|
|
|
return NumCycles == 1;
|
|
|
|
}
|
|
|
|
|
2016-02-23 10:46:52 +08:00
|
|
|
bool SystemZInstrInfo::PredicateInstruction(
|
|
|
|
MachineInstr &MI, ArrayRef<MachineOperand> Pred) const {
|
[SystemZ] Be more careful about inverting CC masks
System z branches have a mask to select which of the 4 CC values should
cause the branch to be taken. We can invert a branch by inverting the mask.
However, not all instructions can produce all 4 CC values, so inverting
the branch like this can lead to some oddities. For example, integer
comparisons only produce a CC of 0 (equal), 1 (less) or 2 (greater).
If an integer EQ is reversed to NE before instruction selection,
the branch will test for 1 or 2. If instead the branch is reversed
after instruction selection (by inverting the mask), it will test for
1, 2 or 3. Both are correct, but the second isn't really canonical.
This patch therefore keeps track of which CC values are possible
and uses this when inverting a mask.
Although this is mostly cosmestic, it fixes undefined behavior
for the CIJNLH in branch-08.ll. Another fix would have been
to mask out bit 0 when generating the fused compare and branch,
but the point of this patch is that we shouldn't need to do that
in the first place.
The patch also makes it easier to reuse CC results from other instructions.
llvm-svn: 187495
2013-07-31 20:30:20 +08:00
|
|
|
assert(Pred.size() == 2 && "Invalid condition");
|
|
|
|
unsigned CCValid = Pred[0].getImm();
|
|
|
|
unsigned CCMask = Pred[1].getImm();
|
2013-07-25 17:11:15 +08:00
|
|
|
assert(CCMask > 0 && CCMask < 15 && "Invalid predicate");
|
2016-02-23 10:46:52 +08:00
|
|
|
unsigned Opcode = MI.getOpcode();
|
2016-06-11 03:58:10 +08:00
|
|
|
if (Opcode == SystemZ::Trap) {
|
|
|
|
MI.setDesc(get(SystemZ::CondTrap));
|
|
|
|
MachineInstrBuilder(*MI.getParent()->getParent(), MI)
|
|
|
|
.addImm(CCValid).addImm(CCMask)
|
|
|
|
.addReg(SystemZ::CC, RegState::Implicit);
|
|
|
|
return true;
|
|
|
|
}
|
2016-04-08 00:11:44 +08:00
|
|
|
if (Opcode == SystemZ::Return) {
|
|
|
|
MI.setDesc(get(SystemZ::CondReturn));
|
|
|
|
MachineInstrBuilder(*MI.getParent()->getParent(), MI)
|
|
|
|
.addImm(CCValid).addImm(CCMask)
|
|
|
|
.addReg(SystemZ::CC, RegState::Implicit);
|
|
|
|
return true;
|
|
|
|
}
|
2016-04-09 01:22:19 +08:00
|
|
|
if (Opcode == SystemZ::CallJG) {
|
2016-07-07 23:34:46 +08:00
|
|
|
MachineOperand FirstOp = MI.getOperand(0);
|
2016-04-09 01:22:19 +08:00
|
|
|
const uint32_t *RegMask = MI.getOperand(1).getRegMask();
|
|
|
|
MI.RemoveOperand(1);
|
|
|
|
MI.RemoveOperand(0);
|
|
|
|
MI.setDesc(get(SystemZ::CallBRCL));
|
|
|
|
MachineInstrBuilder(*MI.getParent()->getParent(), MI)
|
2017-01-13 17:58:52 +08:00
|
|
|
.addImm(CCValid)
|
|
|
|
.addImm(CCMask)
|
|
|
|
.add(FirstOp)
|
|
|
|
.addRegMask(RegMask)
|
|
|
|
.addReg(SystemZ::CC, RegState::Implicit);
|
2016-04-09 01:22:19 +08:00
|
|
|
return true;
|
|
|
|
}
|
2016-04-11 20:12:32 +08:00
|
|
|
if (Opcode == SystemZ::CallBR) {
|
|
|
|
const uint32_t *RegMask = MI.getOperand(0).getRegMask();
|
|
|
|
MI.RemoveOperand(0);
|
|
|
|
MI.setDesc(get(SystemZ::CallBCR));
|
|
|
|
MachineInstrBuilder(*MI.getParent()->getParent(), MI)
|
|
|
|
.addImm(CCValid).addImm(CCMask)
|
|
|
|
.addRegMask(RegMask)
|
|
|
|
.addReg(SystemZ::CC, RegState::Implicit);
|
|
|
|
return true;
|
|
|
|
}
|
2013-07-25 17:11:15 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-09-22 19:15:07 +08:00
|
|
|
void SystemZInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
|
|
|
|
MachineBasicBlock::iterator MBBI,
|
2016-06-12 23:39:02 +08:00
|
|
|
const DebugLoc &DL, unsigned DestReg,
|
2015-09-22 19:15:07 +08:00
|
|
|
unsigned SrcReg, bool KillSrc) const {
|
2017-05-04 21:33:30 +08:00
|
|
|
// Split 128-bit GPR moves into two 64-bit moves. Add implicit uses of the
|
|
|
|
// super register in case one of the subregs is undefined.
|
|
|
|
// This handles ADDR128 too.
|
2013-05-07 00:15:19 +08:00
|
|
|
if (SystemZ::GR128BitRegClass.contains(DestReg, SrcReg)) {
|
2013-09-30 18:28:35 +08:00
|
|
|
copyPhysReg(MBB, MBBI, DL, RI.getSubReg(DestReg, SystemZ::subreg_h64),
|
|
|
|
RI.getSubReg(SrcReg, SystemZ::subreg_h64), KillSrc);
|
2017-05-04 21:33:30 +08:00
|
|
|
MachineInstrBuilder(*MBB.getParent(), std::prev(MBBI))
|
|
|
|
.addReg(SrcReg, RegState::Implicit);
|
2013-09-30 18:28:35 +08:00
|
|
|
copyPhysReg(MBB, MBBI, DL, RI.getSubReg(DestReg, SystemZ::subreg_l64),
|
|
|
|
RI.getSubReg(SrcReg, SystemZ::subreg_l64), KillSrc);
|
2017-05-04 21:33:30 +08:00
|
|
|
MachineInstrBuilder(*MBB.getParent(), std::prev(MBBI))
|
|
|
|
.addReg(SrcReg, (getKillRegState(KillSrc) | RegState::Implicit));
|
2013-05-07 00:15:19 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-01 19:26:28 +08:00
|
|
|
if (SystemZ::GRX32BitRegClass.contains(DestReg, SrcReg)) {
|
2017-01-18 16:32:54 +08:00
|
|
|
emitGRX32Move(MBB, MBBI, DL, DestReg, SrcReg, SystemZ::LR, 32, KillSrc,
|
|
|
|
false);
|
2013-10-01 19:26:28 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
// Everything else needs only one instruction.
|
|
|
|
unsigned Opcode;
|
2013-10-01 19:26:28 +08:00
|
|
|
if (SystemZ::GR64BitRegClass.contains(DestReg, SrcReg))
|
2013-05-07 00:15:19 +08:00
|
|
|
Opcode = SystemZ::LGR;
|
|
|
|
else if (SystemZ::FP32BitRegClass.contains(DestReg, SrcReg))
|
2016-03-14 21:50:03 +08:00
|
|
|
// For z13 we prefer LDR over LER to avoid partial register dependencies.
|
|
|
|
Opcode = STI.hasVector() ? SystemZ::LDR32 : SystemZ::LER;
|
2013-05-07 00:15:19 +08:00
|
|
|
else if (SystemZ::FP64BitRegClass.contains(DestReg, SrcReg))
|
|
|
|
Opcode = SystemZ::LDR;
|
|
|
|
else if (SystemZ::FP128BitRegClass.contains(DestReg, SrcReg))
|
|
|
|
Opcode = SystemZ::LXR;
|
2015-05-06 03:28:34 +08:00
|
|
|
else if (SystemZ::VR32BitRegClass.contains(DestReg, SrcReg))
|
|
|
|
Opcode = SystemZ::VLR32;
|
|
|
|
else if (SystemZ::VR64BitRegClass.contains(DestReg, SrcReg))
|
|
|
|
Opcode = SystemZ::VLR64;
|
[SystemZ] Add CodeGen support for integer vector types
This the first of a series of patches to add CodeGen support exploiting
the instructions of the z13 vector facility. This patch adds support
for the native integer vector types (v16i8, v8i16, v4i32, v2i64).
When the vector facility is present, we default to the new vector ABI.
This is characterized by two major differences:
- Vector types are passed/returned in vector registers
(except for unnamed arguments of a variable-argument list function).
- Vector types are at most 8-byte aligned.
The reason for the choice of 8-byte vector alignment is that the hardware
is able to efficiently load vectors at 8-byte alignment, and the ABI only
guarantees 8-byte alignment of the stack pointer, so requiring any higher
alignment for vectors would require dynamic stack re-alignment code.
However, for compatibility with old code that may use vector types, when
*not* using the vector facility, the old alignment rules (vector types
are naturally aligned) remain in use.
These alignment rules are not only implemented at the C language level
(implemented in clang), but also at the LLVM IR level. This is done
by selecting a different DataLayout string depending on whether the
vector ABI is in effect or not.
Based on a patch by Richard Sandiford.
llvm-svn: 236521
2015-05-06 03:25:42 +08:00
|
|
|
else if (SystemZ::VR128BitRegClass.contains(DestReg, SrcReg))
|
|
|
|
Opcode = SystemZ::VLR;
|
2016-11-09 04:15:26 +08:00
|
|
|
else if (SystemZ::AR32BitRegClass.contains(DestReg, SrcReg))
|
|
|
|
Opcode = SystemZ::CPYA;
|
|
|
|
else if (SystemZ::AR32BitRegClass.contains(DestReg) &&
|
|
|
|
SystemZ::GR32BitRegClass.contains(SrcReg))
|
|
|
|
Opcode = SystemZ::SAR;
|
|
|
|
else if (SystemZ::GR32BitRegClass.contains(DestReg) &&
|
|
|
|
SystemZ::AR32BitRegClass.contains(SrcReg))
|
|
|
|
Opcode = SystemZ::EAR;
|
2013-05-07 00:15:19 +08:00
|
|
|
else
|
|
|
|
llvm_unreachable("Impossible reg-to-reg copy");
|
|
|
|
|
|
|
|
BuildMI(MBB, MBBI, DL, get(Opcode), DestReg)
|
|
|
|
.addReg(SrcReg, getKillRegState(KillSrc));
|
|
|
|
}
|
|
|
|
|
2015-09-22 19:15:07 +08:00
|
|
|
void SystemZInstrInfo::storeRegToStackSlot(
|
|
|
|
MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned SrcReg,
|
|
|
|
bool isKill, int FrameIdx, const TargetRegisterClass *RC,
|
|
|
|
const TargetRegisterInfo *TRI) const {
|
2013-05-07 00:15:19 +08:00
|
|
|
DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
|
|
|
|
|
|
|
|
// Callers may expect a single instruction, so keep 128-bit moves
|
|
|
|
// together for now and lower them after register allocation.
|
|
|
|
unsigned LoadOpcode, StoreOpcode;
|
|
|
|
getLoadStoreOpcodes(RC, LoadOpcode, StoreOpcode);
|
|
|
|
addFrameReference(BuildMI(MBB, MBBI, DL, get(StoreOpcode))
|
2015-09-22 19:15:07 +08:00
|
|
|
.addReg(SrcReg, getKillRegState(isKill)),
|
|
|
|
FrameIdx);
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
|
2015-09-22 19:15:07 +08:00
|
|
|
void SystemZInstrInfo::loadRegFromStackSlot(
|
|
|
|
MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned DestReg,
|
|
|
|
int FrameIdx, const TargetRegisterClass *RC,
|
|
|
|
const TargetRegisterInfo *TRI) const {
|
2013-05-07 00:15:19 +08:00
|
|
|
DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
|
|
|
|
|
|
|
|
// Callers may expect a single instruction, so keep 128-bit moves
|
|
|
|
// together for now and lower them after register allocation.
|
|
|
|
unsigned LoadOpcode, StoreOpcode;
|
|
|
|
getLoadStoreOpcodes(RC, LoadOpcode, StoreOpcode);
|
|
|
|
addFrameReference(BuildMI(MBB, MBBI, DL, get(LoadOpcode), DestReg),
|
|
|
|
FrameIdx);
|
|
|
|
}
|
|
|
|
|
2013-07-02 23:28:56 +08:00
|
|
|
// Return true if MI is a simple load or store with a 12-bit displacement
|
|
|
|
// and no index. Flag is SimpleBDXLoad for loads and SimpleBDXStore for stores.
|
|
|
|
static bool isSimpleBD12Move(const MachineInstr *MI, unsigned Flag) {
|
|
|
|
const MCInstrDesc &MCID = MI->getDesc();
|
|
|
|
return ((MCID.TSFlags & Flag) &&
|
|
|
|
isUInt<12>(MI->getOperand(2).getImm()) &&
|
|
|
|
MI->getOperand(3).getReg() == 0);
|
|
|
|
}
|
|
|
|
|
2013-07-31 19:36:35 +08:00
|
|
|
namespace {
|
2017-01-25 06:10:43 +08:00
|
|
|
|
2014-03-06 18:38:30 +08:00
|
|
|
struct LogicOp {
|
2017-01-25 06:10:43 +08:00
|
|
|
LogicOp() = default;
|
2014-03-06 18:38:30 +08:00
|
|
|
LogicOp(unsigned regSize, unsigned immLSB, unsigned immSize)
|
|
|
|
: RegSize(regSize), ImmLSB(immLSB), ImmSize(immSize) {}
|
2013-07-31 19:36:35 +08:00
|
|
|
|
2015-02-16 06:00:20 +08:00
|
|
|
explicit operator bool() const { return RegSize; }
|
2013-07-31 19:36:35 +08:00
|
|
|
|
2017-01-25 06:10:43 +08:00
|
|
|
unsigned RegSize = 0;
|
|
|
|
unsigned ImmLSB = 0;
|
|
|
|
unsigned ImmSize = 0;
|
2014-03-06 18:38:30 +08:00
|
|
|
};
|
2017-01-25 06:10:43 +08:00
|
|
|
|
2014-03-06 18:38:30 +08:00
|
|
|
} // end anonymous namespace
|
2013-07-31 19:36:35 +08:00
|
|
|
|
|
|
|
static LogicOp interpretAndImmediate(unsigned Opcode) {
|
|
|
|
switch (Opcode) {
|
2013-10-01 22:20:41 +08:00
|
|
|
case SystemZ::NILMux: return LogicOp(32, 0, 16);
|
|
|
|
case SystemZ::NIHMux: return LogicOp(32, 16, 16);
|
2013-09-25 19:11:53 +08:00
|
|
|
case SystemZ::NILL64: return LogicOp(64, 0, 16);
|
|
|
|
case SystemZ::NILH64: return LogicOp(64, 16, 16);
|
2013-10-01 22:20:41 +08:00
|
|
|
case SystemZ::NIHL64: return LogicOp(64, 32, 16);
|
|
|
|
case SystemZ::NIHH64: return LogicOp(64, 48, 16);
|
|
|
|
case SystemZ::NIFMux: return LogicOp(32, 0, 32);
|
2013-09-25 19:11:53 +08:00
|
|
|
case SystemZ::NILF64: return LogicOp(64, 0, 32);
|
2013-10-01 22:20:41 +08:00
|
|
|
case SystemZ::NIHF64: return LogicOp(64, 32, 32);
|
2013-07-31 19:36:35 +08:00
|
|
|
default: return LogicOp();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-02 17:37:40 +08:00
|
|
|
static void transferDeadCC(MachineInstr *OldMI, MachineInstr *NewMI) {
|
|
|
|
if (OldMI->registerDefIsDead(SystemZ::CC)) {
|
|
|
|
MachineOperand *CCDef = NewMI->findRegisterDefOperand(SystemZ::CC);
|
|
|
|
if (CCDef != nullptr)
|
|
|
|
CCDef->setIsDead(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-31 19:36:35 +08:00
|
|
|
// Used to return from convertToThreeAddress after replacing two-address
|
|
|
|
// instruction OldMI with three-address instruction NewMI.
|
|
|
|
static MachineInstr *finishConvertToThreeAddress(MachineInstr *OldMI,
|
|
|
|
MachineInstr *NewMI,
|
|
|
|
LiveVariables *LV) {
|
|
|
|
if (LV) {
|
|
|
|
unsigned NumOps = OldMI->getNumOperands();
|
|
|
|
for (unsigned I = 1; I < NumOps; ++I) {
|
|
|
|
MachineOperand &Op = OldMI->getOperand(I);
|
|
|
|
if (Op.isReg() && Op.isKill())
|
2016-07-01 09:51:32 +08:00
|
|
|
LV->replaceKillInstruction(Op.getReg(), *OldMI, *NewMI);
|
2013-07-31 19:36:35 +08:00
|
|
|
}
|
|
|
|
}
|
2016-05-02 17:37:40 +08:00
|
|
|
transferDeadCC(OldMI, NewMI);
|
2013-07-31 19:36:35 +08:00
|
|
|
return NewMI;
|
|
|
|
}
|
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
MachineInstr *SystemZInstrInfo::convertToThreeAddress(
|
|
|
|
MachineFunction::iterator &MFI, MachineInstr &MI, LiveVariables *LV) const {
|
|
|
|
MachineBasicBlock *MBB = MI.getParent();
|
2015-12-04 20:48:51 +08:00
|
|
|
MachineFunction *MF = MBB->getParent();
|
|
|
|
MachineRegisterInfo &MRI = MF->getRegInfo();
|
2013-07-20 00:12:08 +08:00
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
unsigned Opcode = MI.getOpcode();
|
|
|
|
unsigned NumOps = MI.getNumOperands();
|
2013-07-20 00:12:08 +08:00
|
|
|
|
|
|
|
// Try to convert something like SLL into SLLK, if supported.
|
|
|
|
// We prefer to keep the two-operand form where possible both
|
|
|
|
// because it tends to be shorter and because some instructions
|
|
|
|
// have memory forms that can be used during spilling.
|
2014-06-27 15:01:17 +08:00
|
|
|
if (STI.hasDistinctOps()) {
|
2016-06-30 08:01:54 +08:00
|
|
|
MachineOperand &Dest = MI.getOperand(0);
|
|
|
|
MachineOperand &Src = MI.getOperand(1);
|
2013-10-01 22:53:46 +08:00
|
|
|
unsigned DestReg = Dest.getReg();
|
|
|
|
unsigned SrcReg = Src.getReg();
|
|
|
|
// AHIMux is only really a three-operand instruction when both operands
|
|
|
|
// are low registers. Try to constrain both operands to be low if
|
|
|
|
// possible.
|
|
|
|
if (Opcode == SystemZ::AHIMux &&
|
|
|
|
TargetRegisterInfo::isVirtualRegister(DestReg) &&
|
|
|
|
TargetRegisterInfo::isVirtualRegister(SrcReg) &&
|
|
|
|
MRI.getRegClass(DestReg)->contains(SystemZ::R1L) &&
|
|
|
|
MRI.getRegClass(SrcReg)->contains(SystemZ::R1L)) {
|
|
|
|
MRI.constrainRegClass(DestReg, &SystemZ::GR32BitRegClass);
|
|
|
|
MRI.constrainRegClass(SrcReg, &SystemZ::GR32BitRegClass);
|
|
|
|
}
|
2013-07-20 00:12:08 +08:00
|
|
|
int ThreeOperandOpcode = SystemZ::getThreeOperandOpcode(Opcode);
|
|
|
|
if (ThreeOperandOpcode >= 0) {
|
2015-12-04 20:48:51 +08:00
|
|
|
// Create three address instruction without adding the implicit
|
|
|
|
// operands. Those will instead be copied over from the original
|
|
|
|
// instruction by the loop below.
|
2016-06-30 08:01:54 +08:00
|
|
|
MachineInstrBuilder MIB(
|
|
|
|
*MF, MF->CreateMachineInstr(get(ThreeOperandOpcode), MI.getDebugLoc(),
|
|
|
|
/*NoImplicit=*/true));
|
2017-01-13 17:58:52 +08:00
|
|
|
MIB.add(Dest);
|
2013-07-20 00:12:08 +08:00
|
|
|
// Keep the kill state, but drop the tied flag.
|
2013-07-31 19:36:35 +08:00
|
|
|
MIB.addReg(Src.getReg(), getKillRegState(Src.isKill()), Src.getSubReg());
|
2013-07-20 00:12:08 +08:00
|
|
|
// Keep the remaining operands as-is.
|
|
|
|
for (unsigned I = 2; I < NumOps; ++I)
|
2017-01-13 17:58:52 +08:00
|
|
|
MIB.add(MI.getOperand(I));
|
2015-12-04 20:48:51 +08:00
|
|
|
MBB->insert(MI, MIB);
|
2016-06-30 08:01:54 +08:00
|
|
|
return finishConvertToThreeAddress(&MI, MIB, LV);
|
2013-07-31 19:36:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try to convert an AND into an RISBG-type instruction.
|
|
|
|
if (LogicOp And = interpretAndImmediate(Opcode)) {
|
2016-06-30 08:01:54 +08:00
|
|
|
uint64_t Imm = MI.getOperand(2).getImm() << And.ImmLSB;
|
2013-10-01 22:20:41 +08:00
|
|
|
// AND IMMEDIATE leaves the other bits of the register unchanged.
|
|
|
|
Imm |= allOnes(And.RegSize) & ~(allOnes(And.ImmSize) << And.ImmLSB);
|
|
|
|
unsigned Start, End;
|
|
|
|
if (isRxSBGMask(Imm, And.RegSize, Start, End)) {
|
|
|
|
unsigned NewOpcode;
|
2015-03-31 20:58:17 +08:00
|
|
|
if (And.RegSize == 64) {
|
2013-10-01 22:20:41 +08:00
|
|
|
NewOpcode = SystemZ::RISBG;
|
2015-03-31 20:58:17 +08:00
|
|
|
// Prefer RISBGN if available, since it does not clobber CC.
|
|
|
|
if (STI.hasMiscellaneousExtensions())
|
|
|
|
NewOpcode = SystemZ::RISBGN;
|
|
|
|
} else {
|
2013-10-01 22:20:41 +08:00
|
|
|
NewOpcode = SystemZ::RISBMux;
|
|
|
|
Start &= 31;
|
|
|
|
End &= 31;
|
2013-07-20 00:12:08 +08:00
|
|
|
}
|
2016-06-30 08:01:54 +08:00
|
|
|
MachineOperand &Dest = MI.getOperand(0);
|
|
|
|
MachineOperand &Src = MI.getOperand(1);
|
2013-10-01 22:20:41 +08:00
|
|
|
MachineInstrBuilder MIB =
|
2016-06-30 08:01:54 +08:00
|
|
|
BuildMI(*MBB, MI, MI.getDebugLoc(), get(NewOpcode))
|
2017-01-13 17:58:52 +08:00
|
|
|
.add(Dest)
|
2016-06-30 08:01:54 +08:00
|
|
|
.addReg(0)
|
|
|
|
.addReg(Src.getReg(), getKillRegState(Src.isKill()),
|
|
|
|
Src.getSubReg())
|
|
|
|
.addImm(Start)
|
|
|
|
.addImm(End + 128)
|
|
|
|
.addImm(0);
|
|
|
|
return finishConvertToThreeAddress(&MI, MIB, LV);
|
2013-07-20 00:12:08 +08:00
|
|
|
}
|
|
|
|
}
|
2014-04-25 13:30:21 +08:00
|
|
|
return nullptr;
|
2013-07-20 00:12:08 +08:00
|
|
|
}
|
|
|
|
|
2015-06-09 04:09:58 +08:00
|
|
|
MachineInstr *SystemZInstrInfo::foldMemoryOperandImpl(
|
2016-06-30 08:01:54 +08:00
|
|
|
MachineFunction &MF, MachineInstr &MI, ArrayRef<unsigned> Ops,
|
2016-05-10 16:09:37 +08:00
|
|
|
MachineBasicBlock::iterator InsertPt, int FrameIndex,
|
|
|
|
LiveIntervals *LIS) const {
|
|
|
|
const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
|
2016-07-29 02:40:00 +08:00
|
|
|
const MachineFrameInfo &MFI = MF.getFrameInfo();
|
|
|
|
unsigned Size = MFI.getObjectSize(FrameIndex);
|
2016-06-30 08:01:54 +08:00
|
|
|
unsigned Opcode = MI.getOpcode();
|
2013-10-15 16:42:59 +08:00
|
|
|
|
|
|
|
if (Ops.size() == 2 && Ops[0] == 0 && Ops[1] == 1) {
|
2016-06-30 08:01:54 +08:00
|
|
|
if (LIS != nullptr && (Opcode == SystemZ::LA || Opcode == SystemZ::LAY) &&
|
|
|
|
isInt<8>(MI.getOperand(2).getImm()) && !MI.getOperand(3).getReg()) {
|
2016-05-10 16:09:37 +08:00
|
|
|
|
|
|
|
// Check CC liveness, since new instruction introduces a dead
|
|
|
|
// def of CC.
|
|
|
|
MCRegUnitIterator CCUnit(SystemZ::CC, TRI);
|
|
|
|
LiveRange &CCLiveRange = LIS->getRegUnit(*CCUnit);
|
|
|
|
++CCUnit;
|
2017-01-25 06:10:43 +08:00
|
|
|
assert(!CCUnit.isValid() && "CC only has one reg unit.");
|
2016-05-10 16:09:37 +08:00
|
|
|
SlotIndex MISlot =
|
2016-06-30 08:01:54 +08:00
|
|
|
LIS->getSlotIndexes()->getInstructionIndex(MI).getRegSlot();
|
2016-05-10 16:09:37 +08:00
|
|
|
if (!CCLiveRange.liveAt(MISlot)) {
|
|
|
|
// LA(Y) %reg, CONST(%reg) -> AGSI %mem, CONST
|
2016-06-30 08:01:54 +08:00
|
|
|
MachineInstr *BuiltMI = BuildMI(*InsertPt->getParent(), InsertPt,
|
|
|
|
MI.getDebugLoc(), get(SystemZ::AGSI))
|
|
|
|
.addFrameIndex(FrameIndex)
|
|
|
|
.addImm(0)
|
|
|
|
.addImm(MI.getOperand(2).getImm());
|
2016-05-10 16:09:37 +08:00
|
|
|
BuiltMI->findRegisterDefOperand(SystemZ::CC)->setIsDead(true);
|
|
|
|
CCLiveRange.createDeadDef(MISlot, LIS->getVNInfoAllocator());
|
|
|
|
return BuiltMI;
|
|
|
|
}
|
2013-10-15 16:42:59 +08:00
|
|
|
}
|
2014-04-25 13:30:21 +08:00
|
|
|
return nullptr;
|
2013-10-15 16:42:59 +08:00
|
|
|
}
|
2013-07-02 23:28:56 +08:00
|
|
|
|
2013-10-15 16:42:59 +08:00
|
|
|
// All other cases require a single operand.
|
2013-07-02 23:28:56 +08:00
|
|
|
if (Ops.size() != 1)
|
2014-04-25 13:30:21 +08:00
|
|
|
return nullptr;
|
2013-07-02 23:28:56 +08:00
|
|
|
|
|
|
|
unsigned OpNum = Ops[0];
|
2017-04-25 02:55:33 +08:00
|
|
|
assert(Size * 8 ==
|
|
|
|
TRI->getRegSizeInBits(*MF.getRegInfo()
|
|
|
|
.getRegClass(MI.getOperand(OpNum).getReg())) &&
|
2013-07-03 05:17:31 +08:00
|
|
|
"Invalid size combination");
|
2013-07-02 23:28:56 +08:00
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
if ((Opcode == SystemZ::AHI || Opcode == SystemZ::AGHI) && OpNum == 0 &&
|
|
|
|
isInt<8>(MI.getOperand(2).getImm())) {
|
2013-10-15 16:42:59 +08:00
|
|
|
// A(G)HI %reg, CONST -> A(G)SI %mem, CONST
|
|
|
|
Opcode = (Opcode == SystemZ::AHI ? SystemZ::ASI : SystemZ::AGSI);
|
2016-05-02 17:37:40 +08:00
|
|
|
MachineInstr *BuiltMI =
|
2016-06-30 08:01:54 +08:00
|
|
|
BuildMI(*InsertPt->getParent(), InsertPt, MI.getDebugLoc(), get(Opcode))
|
|
|
|
.addFrameIndex(FrameIndex)
|
|
|
|
.addImm(0)
|
|
|
|
.addImm(MI.getOperand(2).getImm());
|
|
|
|
transferDeadCC(&MI, BuiltMI);
|
2016-05-02 17:37:40 +08:00
|
|
|
return BuiltMI;
|
2013-10-15 16:42:59 +08:00
|
|
|
}
|
|
|
|
|
2013-07-12 16:37:17 +08:00
|
|
|
if (Opcode == SystemZ::LGDR || Opcode == SystemZ::LDGR) {
|
|
|
|
bool Op0IsGPR = (Opcode == SystemZ::LGDR);
|
|
|
|
bool Op1IsGPR = (Opcode == SystemZ::LDGR);
|
|
|
|
// If we're spilling the destination of an LDGR or LGDR, store the
|
|
|
|
// source register instead.
|
|
|
|
if (OpNum == 0) {
|
|
|
|
unsigned StoreOpcode = Op1IsGPR ? SystemZ::STG : SystemZ::STD;
|
2016-06-30 08:01:54 +08:00
|
|
|
return BuildMI(*InsertPt->getParent(), InsertPt, MI.getDebugLoc(),
|
2015-06-09 04:09:58 +08:00
|
|
|
get(StoreOpcode))
|
2017-01-13 17:58:52 +08:00
|
|
|
.add(MI.getOperand(1))
|
2015-06-09 04:09:58 +08:00
|
|
|
.addFrameIndex(FrameIndex)
|
|
|
|
.addImm(0)
|
|
|
|
.addReg(0);
|
2013-07-12 16:37:17 +08:00
|
|
|
}
|
|
|
|
// If we're spilling the source of an LDGR or LGDR, load the
|
|
|
|
// destination register instead.
|
|
|
|
if (OpNum == 1) {
|
|
|
|
unsigned LoadOpcode = Op0IsGPR ? SystemZ::LG : SystemZ::LD;
|
2016-06-30 08:01:54 +08:00
|
|
|
return BuildMI(*InsertPt->getParent(), InsertPt, MI.getDebugLoc(),
|
2017-03-21 13:49:40 +08:00
|
|
|
get(LoadOpcode))
|
|
|
|
.add(MI.getOperand(0))
|
|
|
|
.addFrameIndex(FrameIndex)
|
|
|
|
.addImm(0)
|
|
|
|
.addReg(0);
|
2013-07-12 16:37:17 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-02 23:28:56 +08:00
|
|
|
// Look for cases where the source of a simple store or the destination
|
|
|
|
// of a simple load is being spilled. Try to use MVC instead.
|
|
|
|
//
|
|
|
|
// Although MVC is in practice a fast choice in these cases, it is still
|
|
|
|
// logically a bytewise copy. This means that we cannot use it if the
|
2013-09-27 23:29:20 +08:00
|
|
|
// load or store is volatile. We also wouldn't be able to use MVC if
|
|
|
|
// the two memories partially overlap, but that case cannot occur here,
|
|
|
|
// because we know that one of the memories is a full frame index.
|
|
|
|
//
|
|
|
|
// For performance reasons, we also want to avoid using MVC if the addresses
|
|
|
|
// might be equal. We don't worry about that case here, because spill slot
|
|
|
|
// coloring happens later, and because we have special code to remove
|
|
|
|
// MVCs that turn out to be redundant.
|
2016-06-30 08:01:54 +08:00
|
|
|
if (OpNum == 0 && MI.hasOneMemOperand()) {
|
|
|
|
MachineMemOperand *MMO = *MI.memoperands_begin();
|
2013-07-02 23:28:56 +08:00
|
|
|
if (MMO->getSize() == Size && !MMO->isVolatile()) {
|
|
|
|
// Handle conversion of loads.
|
2016-06-30 08:01:54 +08:00
|
|
|
if (isSimpleBD12Move(&MI, SystemZII::SimpleBDXLoad)) {
|
|
|
|
return BuildMI(*InsertPt->getParent(), InsertPt, MI.getDebugLoc(),
|
2015-06-09 04:09:58 +08:00
|
|
|
get(SystemZ::MVC))
|
|
|
|
.addFrameIndex(FrameIndex)
|
|
|
|
.addImm(0)
|
|
|
|
.addImm(Size)
|
2017-01-13 17:58:52 +08:00
|
|
|
.add(MI.getOperand(1))
|
2016-06-30 08:01:54 +08:00
|
|
|
.addImm(MI.getOperand(2).getImm())
|
2015-06-09 04:09:58 +08:00
|
|
|
.addMemOperand(MMO);
|
2013-07-02 23:28:56 +08:00
|
|
|
}
|
|
|
|
// Handle conversion of stores.
|
2016-06-30 08:01:54 +08:00
|
|
|
if (isSimpleBD12Move(&MI, SystemZII::SimpleBDXStore)) {
|
|
|
|
return BuildMI(*InsertPt->getParent(), InsertPt, MI.getDebugLoc(),
|
2015-06-09 04:09:58 +08:00
|
|
|
get(SystemZ::MVC))
|
2017-01-13 17:58:52 +08:00
|
|
|
.add(MI.getOperand(1))
|
2016-06-30 08:01:54 +08:00
|
|
|
.addImm(MI.getOperand(2).getImm())
|
2015-06-09 04:09:58 +08:00
|
|
|
.addImm(Size)
|
|
|
|
.addFrameIndex(FrameIndex)
|
|
|
|
.addImm(0)
|
|
|
|
.addMemOperand(MMO);
|
2013-07-02 23:28:56 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-03 18:10:02 +08:00
|
|
|
// If the spilled operand is the final one, try to change <INSN>R
|
|
|
|
// into <INSN>.
|
2013-07-12 16:37:17 +08:00
|
|
|
int MemOpcode = SystemZ::getMemOpcode(Opcode);
|
2013-07-03 18:10:02 +08:00
|
|
|
if (MemOpcode >= 0) {
|
2016-06-30 08:01:54 +08:00
|
|
|
unsigned NumOps = MI.getNumExplicitOperands();
|
2013-07-03 18:10:02 +08:00
|
|
|
if (OpNum == NumOps - 1) {
|
|
|
|
const MCInstrDesc &MemDesc = get(MemOpcode);
|
|
|
|
uint64_t AccessBytes = SystemZII::getAccessSize(MemDesc.TSFlags);
|
|
|
|
assert(AccessBytes != 0 && "Size of access should be known");
|
|
|
|
assert(AccessBytes <= Size && "Access outside the frame index");
|
|
|
|
uint64_t Offset = Size - AccessBytes;
|
2015-06-09 04:09:58 +08:00
|
|
|
MachineInstrBuilder MIB = BuildMI(*InsertPt->getParent(), InsertPt,
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.getDebugLoc(), get(MemOpcode));
|
2013-07-03 18:10:02 +08:00
|
|
|
for (unsigned I = 0; I < OpNum; ++I)
|
2017-01-13 17:58:52 +08:00
|
|
|
MIB.add(MI.getOperand(I));
|
2013-07-03 18:10:02 +08:00
|
|
|
MIB.addFrameIndex(FrameIndex).addImm(Offset);
|
|
|
|
if (MemDesc.TSFlags & SystemZII::HasIndex)
|
|
|
|
MIB.addReg(0);
|
2016-06-30 08:01:54 +08:00
|
|
|
transferDeadCC(&MI, MIB);
|
2013-07-03 18:10:02 +08:00
|
|
|
return MIB;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-25 13:30:21 +08:00
|
|
|
return nullptr;
|
2013-07-02 23:28:56 +08:00
|
|
|
}
|
|
|
|
|
2015-06-09 04:09:58 +08:00
|
|
|
MachineInstr *SystemZInstrInfo::foldMemoryOperandImpl(
|
2016-06-30 08:01:54 +08:00
|
|
|
MachineFunction &MF, MachineInstr &MI, ArrayRef<unsigned> Ops,
|
|
|
|
MachineBasicBlock::iterator InsertPt, MachineInstr &LoadMI,
|
2016-05-10 16:09:37 +08:00
|
|
|
LiveIntervals *LIS) const {
|
2014-04-25 13:30:21 +08:00
|
|
|
return nullptr;
|
2013-07-02 23:28:56 +08:00
|
|
|
}
|
|
|
|
|
2016-06-30 08:01:54 +08:00
|
|
|
bool SystemZInstrInfo::expandPostRAPseudo(MachineInstr &MI) const {
|
|
|
|
switch (MI.getOpcode()) {
|
2013-05-07 00:15:19 +08:00
|
|
|
case SystemZ::L128:
|
|
|
|
splitMove(MI, SystemZ::LG);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::ST128:
|
|
|
|
splitMove(MI, SystemZ::STG);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::LX:
|
|
|
|
splitMove(MI, SystemZ::LD);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::STX:
|
|
|
|
splitMove(MI, SystemZ::STD);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 20:11:47 +08:00
|
|
|
case SystemZ::LBMux:
|
|
|
|
expandRXYPseudo(MI, SystemZ::LB, SystemZ::LBH);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::LHMux:
|
|
|
|
expandRXYPseudo(MI, SystemZ::LH, SystemZ::LHH);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 20:49:07 +08:00
|
|
|
case SystemZ::LLCRMux:
|
|
|
|
expandZExtPseudo(MI, SystemZ::LLCR, 8);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::LLHRMux:
|
|
|
|
expandZExtPseudo(MI, SystemZ::LLHR, 16);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 20:19:08 +08:00
|
|
|
case SystemZ::LLCMux:
|
|
|
|
expandRXYPseudo(MI, SystemZ::LLC, SystemZ::LLCH);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::LLHMux:
|
|
|
|
expandRXYPseudo(MI, SystemZ::LLH, SystemZ::LLHH);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 19:26:28 +08:00
|
|
|
case SystemZ::LMux:
|
|
|
|
expandRXYPseudo(MI, SystemZ::L, SystemZ::LFH);
|
|
|
|
return true;
|
|
|
|
|
2016-11-28 21:34:08 +08:00
|
|
|
case SystemZ::LOCMux:
|
|
|
|
expandLOCPseudo(MI, SystemZ::LOC, SystemZ::LOCFH);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::LOCHIMux:
|
|
|
|
expandLOCPseudo(MI, SystemZ::LOCHI, SystemZ::LOCHHI);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::LOCRMux:
|
|
|
|
expandLOCRPseudo(MI, SystemZ::LOCR, SystemZ::LOCFHR);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 20:22:49 +08:00
|
|
|
case SystemZ::STCMux:
|
|
|
|
expandRXYPseudo(MI, SystemZ::STC, SystemZ::STCH);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::STHMux:
|
|
|
|
expandRXYPseudo(MI, SystemZ::STH, SystemZ::STHH);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 19:26:28 +08:00
|
|
|
case SystemZ::STMux:
|
|
|
|
expandRXYPseudo(MI, SystemZ::ST, SystemZ::STFH);
|
|
|
|
return true;
|
|
|
|
|
2016-11-28 21:34:08 +08:00
|
|
|
case SystemZ::STOCMux:
|
|
|
|
expandLOCPseudo(MI, SystemZ::STOC, SystemZ::STOCFH);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 21:02:28 +08:00
|
|
|
case SystemZ::LHIMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::LHI, SystemZ::IIHF, true);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::IIFMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::IILF, SystemZ::IIHF, false);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 21:18:56 +08:00
|
|
|
case SystemZ::IILMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::IILL, SystemZ::IIHL, false);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::IIHMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::IILH, SystemZ::IIHH, false);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 22:20:41 +08:00
|
|
|
case SystemZ::NIFMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::NILF, SystemZ::NIHF, false);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::NILMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::NILL, SystemZ::NIHL, false);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::NIHMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::NILH, SystemZ::NIHH, false);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 21:22:41 +08:00
|
|
|
case SystemZ::OIFMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::OILF, SystemZ::OIHF, false);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::OILMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::OILL, SystemZ::OIHL, false);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::OIHMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::OILH, SystemZ::OIHH, false);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 22:08:44 +08:00
|
|
|
case SystemZ::XIFMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::XILF, SystemZ::XIHF, false);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 22:41:52 +08:00
|
|
|
case SystemZ::TMLMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::TMLL, SystemZ::TMHL, false);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::TMHMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::TMLH, SystemZ::TMHH, false);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 22:53:46 +08:00
|
|
|
case SystemZ::AHIMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::AHI, SystemZ::AIH, false);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::AHIMuxK:
|
|
|
|
expandRIEPseudo(MI, SystemZ::AHI, SystemZ::AHIK, SystemZ::AIH);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::AFIMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::AFI, SystemZ::AIH, false);
|
|
|
|
return true;
|
|
|
|
|
2016-11-28 21:40:08 +08:00
|
|
|
case SystemZ::CHIMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::CHI, SystemZ::CIH, false);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 22:56:23 +08:00
|
|
|
case SystemZ::CFIMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::CFI, SystemZ::CIH, false);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::CLFIMux:
|
|
|
|
expandRIPseudo(MI, SystemZ::CLFI, SystemZ::CLIH, false);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 23:00:44 +08:00
|
|
|
case SystemZ::CMux:
|
|
|
|
expandRXYPseudo(MI, SystemZ::C, SystemZ::CHF);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case SystemZ::CLMux:
|
|
|
|
expandRXYPseudo(MI, SystemZ::CL, SystemZ::CLHF);
|
|
|
|
return true;
|
|
|
|
|
2013-10-01 22:20:41 +08:00
|
|
|
case SystemZ::RISBMux: {
|
2016-06-30 08:01:54 +08:00
|
|
|
bool DestIsHigh = isHighReg(MI.getOperand(0).getReg());
|
|
|
|
bool SrcIsHigh = isHighReg(MI.getOperand(2).getReg());
|
2013-10-01 22:20:41 +08:00
|
|
|
if (SrcIsHigh == DestIsHigh)
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.setDesc(get(DestIsHigh ? SystemZ::RISBHH : SystemZ::RISBLL));
|
2013-10-01 22:20:41 +08:00
|
|
|
else {
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.setDesc(get(DestIsHigh ? SystemZ::RISBHL : SystemZ::RISBLH));
|
|
|
|
MI.getOperand(5).setImm(MI.getOperand(5).getImm() ^ 32);
|
2013-10-01 22:20:41 +08:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
case SystemZ::ADJDYNALLOC:
|
|
|
|
splitAdjDynAlloc(MI);
|
|
|
|
return true;
|
|
|
|
|
2016-04-24 21:57:49 +08:00
|
|
|
case TargetOpcode::LOAD_STACK_GUARD:
|
2016-06-30 08:01:54 +08:00
|
|
|
expandLoadStackGuard(&MI);
|
2016-04-24 21:57:49 +08:00
|
|
|
return true;
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-29 16:16:16 +08:00
|
|
|
unsigned SystemZInstrInfo::getInstSizeInBytes(const MachineInstr &MI) const {
|
2016-06-30 08:01:54 +08:00
|
|
|
if (MI.getOpcode() == TargetOpcode::INLINEASM) {
|
|
|
|
const MachineFunction *MF = MI.getParent()->getParent();
|
|
|
|
const char *AsmStr = MI.getOperand(0).getSymbolName();
|
[SystemZ] Add long branch pass
Before this change, the SystemZ backend would use BRCL for all branches
and only consider shortening them to BRC when generating an object file.
E.g. a branch on equal would use the JGE alias of BRCL in assembly output,
but might be shortened to the JE alias of BRC in ELF output. This was
a useful first step, but it had two problems:
(1) The z assembler isn't traditionally supposed to perform branch shortening
or branch relaxation. We followed this rule by not relaxing branches
in assembler input, but that meant that generating assembly code and
then assembling it would not produce the same result as going directly
to object code; the former would give long branches everywhere, whereas
the latter would use short branches where possible.
(2) Other useful branches, like COMPARE AND BRANCH, do not have long forms.
We would need to do something else before supporting them.
(Although COMPARE AND BRANCH does not change the condition codes,
the plan is to model COMPARE AND BRANCH as a CC-clobbering instruction
during codegen, so that we can safely lower it to a separate compare
and long branch where necessary. This is not a valid transformation
for the assembler proper to make.)
This patch therefore moves branch relaxation to a pre-emit pass.
For now, calls are still shortened from BRASL to BRAS by the assembler,
although this too is not really the traditional behaviour.
The first test takes about 1.5s to run, and there are likely to be
more tests in this vein once further branch types are added. The feeling
on IRC was that 1.5s is a bit much for a single test, so I've restricted
it to SystemZ hosts for now.
The patch exposes (and fixes) some typos in the main CodeGen/SystemZ tests.
A later patch will remove the {{g}}s from that directory.
llvm-svn: 182274
2013-05-20 22:23:08 +08:00
|
|
|
return getInlineAsmLength(AsmStr, *MF->getTarget().getMCAsmInfo());
|
|
|
|
}
|
2016-06-30 08:01:54 +08:00
|
|
|
return MI.getDesc().getSize();
|
[SystemZ] Add long branch pass
Before this change, the SystemZ backend would use BRCL for all branches
and only consider shortening them to BRC when generating an object file.
E.g. a branch on equal would use the JGE alias of BRCL in assembly output,
but might be shortened to the JE alias of BRC in ELF output. This was
a useful first step, but it had two problems:
(1) The z assembler isn't traditionally supposed to perform branch shortening
or branch relaxation. We followed this rule by not relaxing branches
in assembler input, but that meant that generating assembly code and
then assembling it would not produce the same result as going directly
to object code; the former would give long branches everywhere, whereas
the latter would use short branches where possible.
(2) Other useful branches, like COMPARE AND BRANCH, do not have long forms.
We would need to do something else before supporting them.
(Although COMPARE AND BRANCH does not change the condition codes,
the plan is to model COMPARE AND BRANCH as a CC-clobbering instruction
during codegen, so that we can safely lower it to a separate compare
and long branch where necessary. This is not a valid transformation
for the assembler proper to make.)
This patch therefore moves branch relaxation to a pre-emit pass.
For now, calls are still shortened from BRASL to BRAS by the assembler,
although this too is not really the traditional behaviour.
The first test takes about 1.5s to run, and there are likely to be
more tests in this vein once further branch types are added. The feeling
on IRC was that 1.5s is a bit much for a single test, so I've restricted
it to SystemZ hosts for now.
The patch exposes (and fixes) some typos in the main CodeGen/SystemZ tests.
A later patch will remove the {{g}}s from that directory.
llvm-svn: 182274
2013-05-20 22:23:08 +08:00
|
|
|
}
|
|
|
|
|
2013-05-28 18:13:54 +08:00
|
|
|
SystemZII::Branch
|
2016-06-30 08:01:54 +08:00
|
|
|
SystemZInstrInfo::getBranchInfo(const MachineInstr &MI) const {
|
|
|
|
switch (MI.getOpcode()) {
|
2013-05-07 00:15:19 +08:00
|
|
|
case SystemZ::BR:
|
|
|
|
case SystemZ::J:
|
|
|
|
case SystemZ::JG:
|
2013-05-28 18:41:11 +08:00
|
|
|
return SystemZII::Branch(SystemZII::BranchNormal, SystemZ::CCMASK_ANY,
|
2016-06-30 08:01:54 +08:00
|
|
|
SystemZ::CCMASK_ANY, &MI.getOperand(0));
|
2013-05-07 00:15:19 +08:00
|
|
|
|
|
|
|
case SystemZ::BRC:
|
|
|
|
case SystemZ::BRCL:
|
2016-06-30 08:01:54 +08:00
|
|
|
return SystemZII::Branch(SystemZII::BranchNormal, MI.getOperand(0).getImm(),
|
|
|
|
MI.getOperand(1).getImm(), &MI.getOperand(2));
|
2013-05-28 18:41:11 +08:00
|
|
|
|
2013-08-05 19:23:46 +08:00
|
|
|
case SystemZ::BRCT:
|
2016-11-28 21:40:08 +08:00
|
|
|
case SystemZ::BRCTH:
|
2013-08-05 19:23:46 +08:00
|
|
|
return SystemZII::Branch(SystemZII::BranchCT, SystemZ::CCMASK_ICMP,
|
2016-06-30 08:01:54 +08:00
|
|
|
SystemZ::CCMASK_CMP_NE, &MI.getOperand(2));
|
2013-08-05 19:23:46 +08:00
|
|
|
|
|
|
|
case SystemZ::BRCTG:
|
|
|
|
return SystemZII::Branch(SystemZII::BranchCTG, SystemZ::CCMASK_ICMP,
|
2016-06-30 08:01:54 +08:00
|
|
|
SystemZ::CCMASK_CMP_NE, &MI.getOperand(2));
|
2013-08-05 19:23:46 +08:00
|
|
|
|
2013-05-29 19:58:52 +08:00
|
|
|
case SystemZ::CIJ:
|
2013-05-28 18:41:11 +08:00
|
|
|
case SystemZ::CRJ:
|
[SystemZ] Be more careful about inverting CC masks
System z branches have a mask to select which of the 4 CC values should
cause the branch to be taken. We can invert a branch by inverting the mask.
However, not all instructions can produce all 4 CC values, so inverting
the branch like this can lead to some oddities. For example, integer
comparisons only produce a CC of 0 (equal), 1 (less) or 2 (greater).
If an integer EQ is reversed to NE before instruction selection,
the branch will test for 1 or 2. If instead the branch is reversed
after instruction selection (by inverting the mask), it will test for
1, 2 or 3. Both are correct, but the second isn't really canonical.
This patch therefore keeps track of which CC values are possible
and uses this when inverting a mask.
Although this is mostly cosmestic, it fixes undefined behavior
for the CIJNLH in branch-08.ll. Another fix would have been
to mask out bit 0 when generating the fused compare and branch,
but the point of this patch is that we shouldn't need to do that
in the first place.
The patch also makes it easier to reuse CC results from other instructions.
llvm-svn: 187495
2013-07-31 20:30:20 +08:00
|
|
|
return SystemZII::Branch(SystemZII::BranchC, SystemZ::CCMASK_ICMP,
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.getOperand(2).getImm(), &MI.getOperand(3));
|
2013-05-28 18:41:11 +08:00
|
|
|
|
2013-09-18 17:56:40 +08:00
|
|
|
case SystemZ::CLIJ:
|
|
|
|
case SystemZ::CLRJ:
|
|
|
|
return SystemZII::Branch(SystemZII::BranchCL, SystemZ::CCMASK_ICMP,
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.getOperand(2).getImm(), &MI.getOperand(3));
|
2013-09-18 17:56:40 +08:00
|
|
|
|
2013-05-29 19:58:52 +08:00
|
|
|
case SystemZ::CGIJ:
|
2013-05-28 18:41:11 +08:00
|
|
|
case SystemZ::CGRJ:
|
[SystemZ] Be more careful about inverting CC masks
System z branches have a mask to select which of the 4 CC values should
cause the branch to be taken. We can invert a branch by inverting the mask.
However, not all instructions can produce all 4 CC values, so inverting
the branch like this can lead to some oddities. For example, integer
comparisons only produce a CC of 0 (equal), 1 (less) or 2 (greater).
If an integer EQ is reversed to NE before instruction selection,
the branch will test for 1 or 2. If instead the branch is reversed
after instruction selection (by inverting the mask), it will test for
1, 2 or 3. Both are correct, but the second isn't really canonical.
This patch therefore keeps track of which CC values are possible
and uses this when inverting a mask.
Although this is mostly cosmestic, it fixes undefined behavior
for the CIJNLH in branch-08.ll. Another fix would have been
to mask out bit 0 when generating the fused compare and branch,
but the point of this patch is that we shouldn't need to do that
in the first place.
The patch also makes it easier to reuse CC results from other instructions.
llvm-svn: 187495
2013-07-31 20:30:20 +08:00
|
|
|
return SystemZII::Branch(SystemZII::BranchCG, SystemZ::CCMASK_ICMP,
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.getOperand(2).getImm(), &MI.getOperand(3));
|
2013-05-07 00:15:19 +08:00
|
|
|
|
2013-09-18 17:56:40 +08:00
|
|
|
case SystemZ::CLGIJ:
|
|
|
|
case SystemZ::CLGRJ:
|
|
|
|
return SystemZII::Branch(SystemZII::BranchCLG, SystemZ::CCMASK_ICMP,
|
2016-06-30 08:01:54 +08:00
|
|
|
MI.getOperand(2).getImm(), &MI.getOperand(3));
|
2013-09-18 17:56:40 +08:00
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
default:
|
2013-05-28 18:13:54 +08:00
|
|
|
llvm_unreachable("Unrecognized branch opcode");
|
2013-05-07 00:15:19 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SystemZInstrInfo::getLoadStoreOpcodes(const TargetRegisterClass *RC,
|
|
|
|
unsigned &LoadOpcode,
|
|
|
|
unsigned &StoreOpcode) const {
|
|
|
|
if (RC == &SystemZ::GR32BitRegClass || RC == &SystemZ::ADDR32BitRegClass) {
|
|
|
|
LoadOpcode = SystemZ::L;
|
2013-09-25 18:29:47 +08:00
|
|
|
StoreOpcode = SystemZ::ST;
|
2013-10-01 19:26:28 +08:00
|
|
|
} else if (RC == &SystemZ::GRH32BitRegClass) {
|
|
|
|
LoadOpcode = SystemZ::LFH;
|
|
|
|
StoreOpcode = SystemZ::STFH;
|
|
|
|
} else if (RC == &SystemZ::GRX32BitRegClass) {
|
|
|
|
LoadOpcode = SystemZ::LMux;
|
|
|
|
StoreOpcode = SystemZ::STMux;
|
2013-05-07 00:15:19 +08:00
|
|
|
} else if (RC == &SystemZ::GR64BitRegClass ||
|
|
|
|
RC == &SystemZ::ADDR64BitRegClass) {
|
|
|
|
LoadOpcode = SystemZ::LG;
|
|
|
|
StoreOpcode = SystemZ::STG;
|
|
|
|
} else if (RC == &SystemZ::GR128BitRegClass ||
|
|
|
|
RC == &SystemZ::ADDR128BitRegClass) {
|
|
|
|
LoadOpcode = SystemZ::L128;
|
|
|
|
StoreOpcode = SystemZ::ST128;
|
|
|
|
} else if (RC == &SystemZ::FP32BitRegClass) {
|
|
|
|
LoadOpcode = SystemZ::LE;
|
|
|
|
StoreOpcode = SystemZ::STE;
|
|
|
|
} else if (RC == &SystemZ::FP64BitRegClass) {
|
|
|
|
LoadOpcode = SystemZ::LD;
|
|
|
|
StoreOpcode = SystemZ::STD;
|
|
|
|
} else if (RC == &SystemZ::FP128BitRegClass) {
|
|
|
|
LoadOpcode = SystemZ::LX;
|
|
|
|
StoreOpcode = SystemZ::STX;
|
2015-05-06 03:28:34 +08:00
|
|
|
} else if (RC == &SystemZ::VR32BitRegClass) {
|
|
|
|
LoadOpcode = SystemZ::VL32;
|
|
|
|
StoreOpcode = SystemZ::VST32;
|
|
|
|
} else if (RC == &SystemZ::VR64BitRegClass) {
|
|
|
|
LoadOpcode = SystemZ::VL64;
|
|
|
|
StoreOpcode = SystemZ::VST64;
|
[SystemZ] Add CodeGen support for integer vector types
This the first of a series of patches to add CodeGen support exploiting
the instructions of the z13 vector facility. This patch adds support
for the native integer vector types (v16i8, v8i16, v4i32, v2i64).
When the vector facility is present, we default to the new vector ABI.
This is characterized by two major differences:
- Vector types are passed/returned in vector registers
(except for unnamed arguments of a variable-argument list function).
- Vector types are at most 8-byte aligned.
The reason for the choice of 8-byte vector alignment is that the hardware
is able to efficiently load vectors at 8-byte alignment, and the ABI only
guarantees 8-byte alignment of the stack pointer, so requiring any higher
alignment for vectors would require dynamic stack re-alignment code.
However, for compatibility with old code that may use vector types, when
*not* using the vector facility, the old alignment rules (vector types
are naturally aligned) remain in use.
These alignment rules are not only implemented at the C language level
(implemented in clang), but also at the LLVM IR level. This is done
by selecting a different DataLayout string depending on whether the
vector ABI is in effect or not.
Based on a patch by Richard Sandiford.
llvm-svn: 236521
2015-05-06 03:25:42 +08:00
|
|
|
} else if (RC == &SystemZ::VF128BitRegClass ||
|
|
|
|
RC == &SystemZ::VR128BitRegClass) {
|
|
|
|
LoadOpcode = SystemZ::VL;
|
|
|
|
StoreOpcode = SystemZ::VST;
|
2013-05-07 00:15:19 +08:00
|
|
|
} else
|
|
|
|
llvm_unreachable("Unsupported regclass to load or store");
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned SystemZInstrInfo::getOpcodeForOffset(unsigned Opcode,
|
|
|
|
int64_t Offset) const {
|
|
|
|
const MCInstrDesc &MCID = get(Opcode);
|
|
|
|
int64_t Offset2 = (MCID.TSFlags & SystemZII::Is128Bit ? Offset + 8 : Offset);
|
|
|
|
if (isUInt<12>(Offset) && isUInt<12>(Offset2)) {
|
|
|
|
// Get the instruction to use for unsigned 12-bit displacements.
|
|
|
|
int Disp12Opcode = SystemZ::getDisp12Opcode(Opcode);
|
|
|
|
if (Disp12Opcode >= 0)
|
|
|
|
return Disp12Opcode;
|
|
|
|
|
|
|
|
// All address-related instructions can use unsigned 12-bit
|
|
|
|
// displacements.
|
|
|
|
return Opcode;
|
|
|
|
}
|
|
|
|
if (isInt<20>(Offset) && isInt<20>(Offset2)) {
|
|
|
|
// Get the instruction to use for signed 20-bit displacements.
|
|
|
|
int Disp20Opcode = SystemZ::getDisp20Opcode(Opcode);
|
|
|
|
if (Disp20Opcode >= 0)
|
|
|
|
return Disp20Opcode;
|
|
|
|
|
|
|
|
// Check whether Opcode allows signed 20-bit displacements.
|
|
|
|
if (MCID.TSFlags & SystemZII::Has20BitOffset)
|
|
|
|
return Opcode;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-05 19:03:20 +08:00
|
|
|
unsigned SystemZInstrInfo::getLoadAndTest(unsigned Opcode) const {
|
|
|
|
switch (Opcode) {
|
2015-03-31 20:58:17 +08:00
|
|
|
case SystemZ::L: return SystemZ::LT;
|
|
|
|
case SystemZ::LY: return SystemZ::LT;
|
|
|
|
case SystemZ::LG: return SystemZ::LTG;
|
|
|
|
case SystemZ::LGF: return SystemZ::LTGF;
|
|
|
|
case SystemZ::LR: return SystemZ::LTR;
|
|
|
|
case SystemZ::LGFR: return SystemZ::LTGFR;
|
|
|
|
case SystemZ::LGR: return SystemZ::LTGR;
|
|
|
|
case SystemZ::LER: return SystemZ::LTEBR;
|
|
|
|
case SystemZ::LDR: return SystemZ::LTDBR;
|
|
|
|
case SystemZ::LXR: return SystemZ::LTXBR;
|
2015-10-02 02:12:28 +08:00
|
|
|
case SystemZ::LCDFR: return SystemZ::LCDBR;
|
|
|
|
case SystemZ::LPDFR: return SystemZ::LPDBR;
|
|
|
|
case SystemZ::LNDFR: return SystemZ::LNDBR;
|
|
|
|
case SystemZ::LCDFR_32: return SystemZ::LCEBR;
|
|
|
|
case SystemZ::LPDFR_32: return SystemZ::LPEBR;
|
|
|
|
case SystemZ::LNDFR_32: return SystemZ::LNEBR;
|
2015-03-31 20:58:17 +08:00
|
|
|
// On zEC12 we prefer to use RISBGN. But if there is a chance to
|
|
|
|
// actually use the condition code, we may turn it back into RISGB.
|
|
|
|
// Note that RISBG is not really a "load-and-test" instruction,
|
|
|
|
// but sets the same condition code values, so is OK to use here.
|
|
|
|
case SystemZ::RISBGN: return SystemZ::RISBG;
|
|
|
|
default: return 0;
|
2013-08-05 19:03:20 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-31 19:36:35 +08:00
|
|
|
// Return true if Mask matches the regexp 0*1+0*, given that zero masks
|
|
|
|
// have already been filtered out. Store the first set bit in LSB and
|
|
|
|
// the number of set bits in Length if so.
|
|
|
|
static bool isStringOfOnes(uint64_t Mask, unsigned &LSB, unsigned &Length) {
|
|
|
|
unsigned First = findFirstSet(Mask);
|
|
|
|
uint64_t Top = (Mask >> First) + 1;
|
|
|
|
if ((Top & -Top) == Top) {
|
|
|
|
LSB = First;
|
|
|
|
Length = findFirstSet(Top);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SystemZInstrInfo::isRxSBGMask(uint64_t Mask, unsigned BitSize,
|
|
|
|
unsigned &Start, unsigned &End) const {
|
|
|
|
// Reject trivial all-zero masks.
|
[SystemZ] Add CodeGen support for integer vector types
This the first of a series of patches to add CodeGen support exploiting
the instructions of the z13 vector facility. This patch adds support
for the native integer vector types (v16i8, v8i16, v4i32, v2i64).
When the vector facility is present, we default to the new vector ABI.
This is characterized by two major differences:
- Vector types are passed/returned in vector registers
(except for unnamed arguments of a variable-argument list function).
- Vector types are at most 8-byte aligned.
The reason for the choice of 8-byte vector alignment is that the hardware
is able to efficiently load vectors at 8-byte alignment, and the ABI only
guarantees 8-byte alignment of the stack pointer, so requiring any higher
alignment for vectors would require dynamic stack re-alignment code.
However, for compatibility with old code that may use vector types, when
*not* using the vector facility, the old alignment rules (vector types
are naturally aligned) remain in use.
These alignment rules are not only implemented at the C language level
(implemented in clang), but also at the LLVM IR level. This is done
by selecting a different DataLayout string depending on whether the
vector ABI is in effect or not.
Based on a patch by Richard Sandiford.
llvm-svn: 236521
2015-05-06 03:25:42 +08:00
|
|
|
Mask &= allOnes(BitSize);
|
2013-07-31 19:36:35 +08:00
|
|
|
if (Mask == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Handle the 1+0+ or 0+1+0* cases. Start then specifies the index of
|
|
|
|
// the msb and End specifies the index of the lsb.
|
|
|
|
unsigned LSB, Length;
|
|
|
|
if (isStringOfOnes(Mask, LSB, Length)) {
|
|
|
|
Start = 63 - (LSB + Length - 1);
|
|
|
|
End = 63 - LSB;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle the wrap-around 1+0+1+ cases. Start then specifies the msb
|
|
|
|
// of the low 1s and End specifies the lsb of the high 1s.
|
|
|
|
if (isStringOfOnes(Mask ^ allOnes(BitSize), LSB, Length)) {
|
|
|
|
assert(LSB > 0 && "Bottom bit must be set");
|
|
|
|
assert(LSB + Length < BitSize && "Top bit must be set");
|
|
|
|
Start = 63 - (LSB - 1);
|
|
|
|
End = 63 - (LSB + Length);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-06-11 03:58:10 +08:00
|
|
|
unsigned SystemZInstrInfo::getFusedCompare(unsigned Opcode,
|
|
|
|
SystemZII::FusedCompareType Type,
|
|
|
|
const MachineInstr *MI) const {
|
2013-05-28 18:41:11 +08:00
|
|
|
switch (Opcode) {
|
2013-05-29 19:58:52 +08:00
|
|
|
case SystemZ::CHI:
|
|
|
|
case SystemZ::CGHI:
|
2016-04-08 00:11:44 +08:00
|
|
|
if (!(MI && isInt<8>(MI->getOperand(1).getImm())))
|
|
|
|
return 0;
|
|
|
|
break;
|
2013-09-18 17:56:40 +08:00
|
|
|
case SystemZ::CLFI:
|
|
|
|
case SystemZ::CLGFI:
|
2016-04-08 00:11:44 +08:00
|
|
|
if (!(MI && isUInt<8>(MI->getOperand(1).getImm())))
|
|
|
|
return 0;
|
2016-11-11 20:48:26 +08:00
|
|
|
break;
|
|
|
|
case SystemZ::CL:
|
|
|
|
case SystemZ::CLG:
|
|
|
|
if (!STI.hasMiscellaneousExtensions())
|
|
|
|
return 0;
|
|
|
|
if (!(MI && MI->getOperand(3).getReg() == 0))
|
|
|
|
return 0;
|
|
|
|
break;
|
2016-04-08 00:11:44 +08:00
|
|
|
}
|
|
|
|
switch (Type) {
|
|
|
|
case SystemZII::CompareAndBranch:
|
|
|
|
switch (Opcode) {
|
|
|
|
case SystemZ::CR:
|
|
|
|
return SystemZ::CRJ;
|
|
|
|
case SystemZ::CGR:
|
|
|
|
return SystemZ::CGRJ;
|
|
|
|
case SystemZ::CHI:
|
|
|
|
return SystemZ::CIJ;
|
|
|
|
case SystemZ::CGHI:
|
|
|
|
return SystemZ::CGIJ;
|
|
|
|
case SystemZ::CLR:
|
|
|
|
return SystemZ::CLRJ;
|
|
|
|
case SystemZ::CLGR:
|
|
|
|
return SystemZ::CLGRJ;
|
|
|
|
case SystemZ::CLFI:
|
|
|
|
return SystemZ::CLIJ;
|
|
|
|
case SystemZ::CLGFI:
|
|
|
|
return SystemZ::CLGIJ;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
case SystemZII::CompareAndReturn:
|
|
|
|
switch (Opcode) {
|
|
|
|
case SystemZ::CR:
|
|
|
|
return SystemZ::CRBReturn;
|
|
|
|
case SystemZ::CGR:
|
|
|
|
return SystemZ::CGRBReturn;
|
|
|
|
case SystemZ::CHI:
|
|
|
|
return SystemZ::CIBReturn;
|
|
|
|
case SystemZ::CGHI:
|
|
|
|
return SystemZ::CGIBReturn;
|
|
|
|
case SystemZ::CLR:
|
|
|
|
return SystemZ::CLRBReturn;
|
|
|
|
case SystemZ::CLGR:
|
|
|
|
return SystemZ::CLGRBReturn;
|
|
|
|
case SystemZ::CLFI:
|
|
|
|
return SystemZ::CLIBReturn;
|
|
|
|
case SystemZ::CLGFI:
|
|
|
|
return SystemZ::CLGIBReturn;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
2016-04-11 20:12:32 +08:00
|
|
|
case SystemZII::CompareAndSibcall:
|
|
|
|
switch (Opcode) {
|
|
|
|
case SystemZ::CR:
|
|
|
|
return SystemZ::CRBCall;
|
|
|
|
case SystemZ::CGR:
|
|
|
|
return SystemZ::CGRBCall;
|
|
|
|
case SystemZ::CHI:
|
|
|
|
return SystemZ::CIBCall;
|
|
|
|
case SystemZ::CGHI:
|
|
|
|
return SystemZ::CGIBCall;
|
|
|
|
case SystemZ::CLR:
|
|
|
|
return SystemZ::CLRBCall;
|
|
|
|
case SystemZ::CLGR:
|
|
|
|
return SystemZ::CLGRBCall;
|
|
|
|
case SystemZ::CLFI:
|
|
|
|
return SystemZ::CLIBCall;
|
|
|
|
case SystemZ::CLGFI:
|
|
|
|
return SystemZ::CLGIBCall;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
2016-06-11 03:58:10 +08:00
|
|
|
case SystemZII::CompareAndTrap:
|
|
|
|
switch (Opcode) {
|
|
|
|
case SystemZ::CR:
|
|
|
|
return SystemZ::CRT;
|
|
|
|
case SystemZ::CGR:
|
|
|
|
return SystemZ::CGRT;
|
|
|
|
case SystemZ::CHI:
|
|
|
|
return SystemZ::CIT;
|
|
|
|
case SystemZ::CGHI:
|
|
|
|
return SystemZ::CGIT;
|
|
|
|
case SystemZ::CLR:
|
|
|
|
return SystemZ::CLRT;
|
|
|
|
case SystemZ::CLGR:
|
|
|
|
return SystemZ::CLGRT;
|
|
|
|
case SystemZ::CLFI:
|
|
|
|
return SystemZ::CLFIT;
|
|
|
|
case SystemZ::CLGFI:
|
|
|
|
return SystemZ::CLGIT;
|
2016-11-11 20:48:26 +08:00
|
|
|
case SystemZ::CL:
|
|
|
|
return SystemZ::CLT;
|
|
|
|
case SystemZ::CLG:
|
|
|
|
return SystemZ::CLGT;
|
2016-06-11 03:58:10 +08:00
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
2013-05-28 18:41:11 +08:00
|
|
|
}
|
2016-04-08 00:33:25 +08:00
|
|
|
return 0;
|
2013-05-28 18:41:11 +08:00
|
|
|
}
|
|
|
|
|
2016-11-28 21:59:22 +08:00
|
|
|
unsigned SystemZInstrInfo::getLoadAndTrap(unsigned Opcode) const {
|
|
|
|
if (!STI.hasLoadAndTrap())
|
|
|
|
return 0;
|
|
|
|
switch (Opcode) {
|
|
|
|
case SystemZ::L:
|
|
|
|
case SystemZ::LY:
|
|
|
|
return SystemZ::LAT;
|
|
|
|
case SystemZ::LG:
|
|
|
|
return SystemZ::LGAT;
|
|
|
|
case SystemZ::LFH:
|
|
|
|
return SystemZ::LFHAT;
|
|
|
|
case SystemZ::LLGF:
|
|
|
|
return SystemZ::LLGFAT;
|
|
|
|
case SystemZ::LLGT:
|
|
|
|
return SystemZ::LLGTAT;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-05-07 00:15:19 +08:00
|
|
|
void SystemZInstrInfo::loadImmediate(MachineBasicBlock &MBB,
|
|
|
|
MachineBasicBlock::iterator MBBI,
|
|
|
|
unsigned Reg, uint64_t Value) const {
|
|
|
|
DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
|
|
|
|
unsigned Opcode;
|
|
|
|
if (isInt<16>(Value))
|
|
|
|
Opcode = SystemZ::LGHI;
|
|
|
|
else if (SystemZ::isImmLL(Value))
|
|
|
|
Opcode = SystemZ::LLILL;
|
|
|
|
else if (SystemZ::isImmLH(Value)) {
|
|
|
|
Opcode = SystemZ::LLILH;
|
|
|
|
Value >>= 16;
|
|
|
|
} else {
|
|
|
|
assert(isInt<32>(Value) && "Huge values not handled yet");
|
|
|
|
Opcode = SystemZ::LGFI;
|
|
|
|
}
|
|
|
|
BuildMI(MBB, MBBI, DL, get(Opcode), Reg).addImm(Value);
|
|
|
|
}
|
2016-10-20 16:27:16 +08:00
|
|
|
|
|
|
|
bool SystemZInstrInfo::
|
|
|
|
areMemAccessesTriviallyDisjoint(MachineInstr &MIa, MachineInstr &MIb,
|
|
|
|
AliasAnalysis *AA) const {
|
|
|
|
|
|
|
|
if (!MIa.hasOneMemOperand() || !MIb.hasOneMemOperand())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// If mem-operands show that the same address Value is used by both
|
|
|
|
// instructions, check for non-overlapping offsets and widths. Not
|
|
|
|
// sure if a register based analysis would be an improvement...
|
|
|
|
|
|
|
|
MachineMemOperand *MMOa = *MIa.memoperands_begin();
|
|
|
|
MachineMemOperand *MMOb = *MIb.memoperands_begin();
|
|
|
|
const Value *VALa = MMOa->getValue();
|
|
|
|
const Value *VALb = MMOb->getValue();
|
|
|
|
bool SameVal = (VALa && VALb && (VALa == VALb));
|
|
|
|
if (!SameVal) {
|
|
|
|
const PseudoSourceValue *PSVa = MMOa->getPseudoValue();
|
|
|
|
const PseudoSourceValue *PSVb = MMOb->getPseudoValue();
|
|
|
|
if (PSVa && PSVb && (PSVa == PSVb))
|
|
|
|
SameVal = true;
|
|
|
|
}
|
|
|
|
if (SameVal) {
|
|
|
|
int OffsetA = MMOa->getOffset(), OffsetB = MMOb->getOffset();
|
|
|
|
int WidthA = MMOa->getSize(), WidthB = MMOb->getSize();
|
|
|
|
int LowOffset = OffsetA < OffsetB ? OffsetA : OffsetB;
|
|
|
|
int HighOffset = OffsetA < OffsetB ? OffsetB : OffsetA;
|
|
|
|
int LowWidth = (LowOffset == OffsetA) ? WidthA : WidthB;
|
|
|
|
if (LowOffset + LowWidth <= HighOffset)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|