2009-07-29 20:31:52 +00:00
|
|
|
//===- ARMBaseRegisterInfo.cpp - ARM Register Information -------*- C++ -*-===//
|
2009-07-08 17:28:55 +00:00
|
|
|
//
|
|
|
|
// 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 base ARM implementation of TargetRegisterInfo class.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "ARM.h"
|
|
|
|
#include "ARMAddressingModes.h"
|
2009-07-08 18:31:39 +00:00
|
|
|
#include "ARMBaseInstrInfo.h"
|
2009-07-08 17:28:55 +00:00
|
|
|
#include "ARMBaseRegisterInfo.h"
|
|
|
|
#include "ARMInstrInfo.h"
|
|
|
|
#include "ARMMachineFunctionInfo.h"
|
|
|
|
#include "ARMSubtarget.h"
|
|
|
|
#include "llvm/Constants.h"
|
|
|
|
#include "llvm/DerivedTypes.h"
|
2009-07-14 23:09:55 +00:00
|
|
|
#include "llvm/Function.h"
|
|
|
|
#include "llvm/LLVMContext.h"
|
2009-07-08 17:28:55 +00:00
|
|
|
#include "llvm/CodeGen/MachineConstantPool.h"
|
|
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
|
|
|
#include "llvm/CodeGen/MachineLocation.h"
|
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
|
|
|
#include "llvm/CodeGen/RegisterScavenging.h"
|
2009-10-27 22:45:39 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-07-08 18:01:40 +00:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2009-07-08 20:53:28 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2009-07-08 17:28:55 +00:00
|
|
|
#include "llvm/Target/TargetFrameInfo.h"
|
|
|
|
#include "llvm/Target/TargetMachine.h"
|
|
|
|
#include "llvm/Target/TargetOptions.h"
|
|
|
|
#include "llvm/ADT/BitVector.h"
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2009-10-20 20:19:50 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2009-07-08 17:28:55 +00:00
|
|
|
|
2010-04-15 17:34:58 +00:00
|
|
|
namespace llvm {
|
2010-08-24 19:05:43 +00:00
|
|
|
static cl::opt<bool>
|
2010-08-24 21:19:33 +00:00
|
|
|
ForceAllBaseRegAlloc("arm-force-base-reg-alloc", cl::Hidden, cl::init(false),
|
2010-08-24 18:04:52 +00:00
|
|
|
cl::desc("Force use of virtual base registers for stack load/store"));
|
2010-08-24 19:05:43 +00:00
|
|
|
static cl::opt<bool>
|
2010-08-26 00:58:06 +00:00
|
|
|
EnableLocalStackAlloc("enable-local-stack-alloc", cl::init(true), cl::Hidden,
|
2010-08-24 19:05:43 +00:00
|
|
|
cl::desc("Enable pre-regalloc stack frame index allocation"));
|
2010-04-15 17:34:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
using namespace llvm;
|
2009-10-20 20:19:50 +00:00
|
|
|
|
2009-07-08 17:28:55 +00:00
|
|
|
unsigned ARMBaseRegisterInfo::getRegisterNumbering(unsigned RegEnum,
|
2009-07-22 05:55:18 +00:00
|
|
|
bool *isSPVFP) {
|
|
|
|
if (isSPVFP)
|
|
|
|
*isSPVFP = false;
|
2009-07-08 17:28:55 +00:00
|
|
|
|
|
|
|
using namespace ARM;
|
|
|
|
switch (RegEnum) {
|
|
|
|
default:
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unknown ARM register!");
|
2009-07-22 05:55:18 +00:00
|
|
|
case R0: case D0: case Q0: return 0;
|
|
|
|
case R1: case D1: case Q1: return 1;
|
|
|
|
case R2: case D2: case Q2: return 2;
|
|
|
|
case R3: case D3: case Q3: return 3;
|
|
|
|
case R4: case D4: case Q4: return 4;
|
|
|
|
case R5: case D5: case Q5: return 5;
|
|
|
|
case R6: case D6: case Q6: return 6;
|
|
|
|
case R7: case D7: case Q7: return 7;
|
|
|
|
case R8: case D8: case Q8: return 8;
|
|
|
|
case R9: case D9: case Q9: return 9;
|
|
|
|
case R10: case D10: case Q10: return 10;
|
|
|
|
case R11: case D11: case Q11: return 11;
|
|
|
|
case R12: case D12: case Q12: return 12;
|
|
|
|
case SP: case D13: case Q13: return 13;
|
|
|
|
case LR: case D14: case Q14: return 14;
|
|
|
|
case PC: case D15: case Q15: return 15;
|
|
|
|
|
|
|
|
case D16: return 16;
|
|
|
|
case D17: return 17;
|
|
|
|
case D18: return 18;
|
|
|
|
case D19: return 19;
|
|
|
|
case D20: return 20;
|
|
|
|
case D21: return 21;
|
|
|
|
case D22: return 22;
|
|
|
|
case D23: return 23;
|
|
|
|
case D24: return 24;
|
|
|
|
case D25: return 25;
|
2010-03-20 06:05:13 +00:00
|
|
|
case D26: return 26;
|
2009-07-22 05:55:18 +00:00
|
|
|
case D27: return 27;
|
|
|
|
case D28: return 28;
|
|
|
|
case D29: return 29;
|
|
|
|
case D30: return 30;
|
|
|
|
case D31: return 31;
|
2009-07-08 17:28:55 +00:00
|
|
|
|
|
|
|
case S0: case S1: case S2: case S3:
|
|
|
|
case S4: case S5: case S6: case S7:
|
|
|
|
case S8: case S9: case S10: case S11:
|
|
|
|
case S12: case S13: case S14: case S15:
|
|
|
|
case S16: case S17: case S18: case S19:
|
|
|
|
case S20: case S21: case S22: case S23:
|
|
|
|
case S24: case S25: case S26: case S27:
|
2009-07-22 05:55:18 +00:00
|
|
|
case S28: case S29: case S30: case S31: {
|
|
|
|
if (isSPVFP)
|
|
|
|
*isSPVFP = true;
|
2009-07-08 17:28:55 +00:00
|
|
|
switch (RegEnum) {
|
|
|
|
default: return 0; // Avoid compile time warning.
|
|
|
|
case S0: return 0;
|
|
|
|
case S1: return 1;
|
|
|
|
case S2: return 2;
|
|
|
|
case S3: return 3;
|
|
|
|
case S4: return 4;
|
|
|
|
case S5: return 5;
|
|
|
|
case S6: return 6;
|
|
|
|
case S7: return 7;
|
|
|
|
case S8: return 8;
|
|
|
|
case S9: return 9;
|
|
|
|
case S10: return 10;
|
|
|
|
case S11: return 11;
|
|
|
|
case S12: return 12;
|
|
|
|
case S13: return 13;
|
|
|
|
case S14: return 14;
|
|
|
|
case S15: return 15;
|
|
|
|
case S16: return 16;
|
|
|
|
case S17: return 17;
|
|
|
|
case S18: return 18;
|
|
|
|
case S19: return 19;
|
|
|
|
case S20: return 20;
|
|
|
|
case S21: return 21;
|
|
|
|
case S22: return 22;
|
|
|
|
case S23: return 23;
|
|
|
|
case S24: return 24;
|
|
|
|
case S25: return 25;
|
|
|
|
case S26: return 26;
|
|
|
|
case S27: return 27;
|
|
|
|
case S28: return 28;
|
|
|
|
case S29: return 29;
|
|
|
|
case S30: return 30;
|
|
|
|
case S31: return 31;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-08 18:31:39 +00:00
|
|
|
ARMBaseRegisterInfo::ARMBaseRegisterInfo(const ARMBaseInstrInfo &tii,
|
2009-07-08 17:28:55 +00:00
|
|
|
const ARMSubtarget &sti)
|
|
|
|
: ARMGenRegisterInfo(ARM::ADJCALLSTACKDOWN, ARM::ADJCALLSTACKUP),
|
|
|
|
TII(tii), STI(sti),
|
|
|
|
FramePtr((STI.isTargetDarwin() || STI.isThumb()) ? ARM::R7 : ARM::R11) {
|
|
|
|
}
|
|
|
|
|
|
|
|
const unsigned*
|
|
|
|
ARMBaseRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
|
|
|
|
static const unsigned CalleeSavedRegs[] = {
|
|
|
|
ARM::LR, ARM::R11, ARM::R10, ARM::R9, ARM::R8,
|
|
|
|
ARM::R7, ARM::R6, ARM::R5, ARM::R4,
|
|
|
|
|
|
|
|
ARM::D15, ARM::D14, ARM::D13, ARM::D12,
|
|
|
|
ARM::D11, ARM::D10, ARM::D9, ARM::D8,
|
|
|
|
0
|
|
|
|
};
|
|
|
|
|
|
|
|
static const unsigned DarwinCalleeSavedRegs[] = {
|
|
|
|
// Darwin ABI deviates from ARM standard ABI. R9 is not a callee-saved
|
|
|
|
// register.
|
|
|
|
ARM::LR, ARM::R7, ARM::R6, ARM::R5, ARM::R4,
|
|
|
|
ARM::R11, ARM::R10, ARM::R8,
|
|
|
|
|
|
|
|
ARM::D15, ARM::D14, ARM::D13, ARM::D12,
|
|
|
|
ARM::D11, ARM::D10, ARM::D9, ARM::D8,
|
|
|
|
0
|
|
|
|
};
|
|
|
|
return STI.isTargetDarwin() ? DarwinCalleeSavedRegs : CalleeSavedRegs;
|
|
|
|
}
|
|
|
|
|
2010-01-06 23:54:42 +00:00
|
|
|
BitVector ARMBaseRegisterInfo::
|
|
|
|
getReservedRegs(const MachineFunction &MF) const {
|
2009-07-08 17:28:55 +00:00
|
|
|
// FIXME: avoid re-calculating this everytime.
|
|
|
|
BitVector Reserved(getNumRegs());
|
|
|
|
Reserved.set(ARM::SP);
|
|
|
|
Reserved.set(ARM::PC);
|
2010-08-03 21:31:55 +00:00
|
|
|
Reserved.set(ARM::FPSCR);
|
2010-08-10 19:30:19 +00:00
|
|
|
if (hasFP(MF))
|
2009-07-08 17:28:55 +00:00
|
|
|
Reserved.set(FramePtr);
|
|
|
|
// Some targets reserve R9.
|
|
|
|
if (STI.isR9Reserved())
|
|
|
|
Reserved.set(ARM::R9);
|
|
|
|
return Reserved;
|
|
|
|
}
|
|
|
|
|
2009-07-29 20:31:52 +00:00
|
|
|
bool ARMBaseRegisterInfo::isReservedReg(const MachineFunction &MF,
|
|
|
|
unsigned Reg) const {
|
2009-07-08 17:28:55 +00:00
|
|
|
switch (Reg) {
|
|
|
|
default: break;
|
|
|
|
case ARM::SP:
|
|
|
|
case ARM::PC:
|
|
|
|
return true;
|
|
|
|
case ARM::R7:
|
|
|
|
case ARM::R11:
|
2010-08-10 19:30:19 +00:00
|
|
|
if (FramePtr == Reg && hasFP(MF))
|
2009-07-08 17:28:55 +00:00
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
case ARM::R9:
|
|
|
|
return STI.isR9Reserved();
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-10-25 07:53:28 +00:00
|
|
|
const TargetRegisterClass *
|
|
|
|
ARMBaseRegisterInfo::getMatchingSuperRegClass(const TargetRegisterClass *A,
|
|
|
|
const TargetRegisterClass *B,
|
|
|
|
unsigned SubIdx) const {
|
|
|
|
switch (SubIdx) {
|
|
|
|
default: return 0;
|
2010-05-25 00:15:15 +00:00
|
|
|
case ARM::ssub_0:
|
|
|
|
case ARM::ssub_1:
|
|
|
|
case ARM::ssub_2:
|
|
|
|
case ARM::ssub_3: {
|
2009-10-25 07:53:28 +00:00
|
|
|
// S sub-registers.
|
|
|
|
if (A->getSize() == 8) {
|
2009-11-03 05:52:54 +00:00
|
|
|
if (B == &ARM::SPR_8RegClass)
|
|
|
|
return &ARM::DPR_8RegClass;
|
|
|
|
assert(B == &ARM::SPRRegClass && "Expecting SPR register class!");
|
2009-10-25 07:53:28 +00:00
|
|
|
if (A == &ARM::DPR_8RegClass)
|
|
|
|
return A;
|
|
|
|
return &ARM::DPR_VFP2RegClass;
|
|
|
|
}
|
|
|
|
|
2010-05-06 06:36:08 +00:00
|
|
|
if (A->getSize() == 16) {
|
|
|
|
if (B == &ARM::SPR_8RegClass)
|
|
|
|
return &ARM::QPR_8RegClass;
|
|
|
|
return &ARM::QPR_VFP2RegClass;
|
|
|
|
}
|
|
|
|
|
2010-05-14 02:13:41 +00:00
|
|
|
if (A->getSize() == 32) {
|
|
|
|
if (B == &ARM::SPR_8RegClass)
|
|
|
|
return 0; // Do not allow coalescing!
|
|
|
|
return &ARM::QQPR_VFP2RegClass;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(A->getSize() == 64 && "Expecting a QQQQ register class!");
|
|
|
|
return 0; // Do not allow coalescing!
|
2010-05-06 06:36:08 +00:00
|
|
|
}
|
2010-05-25 00:15:15 +00:00
|
|
|
case ARM::dsub_0:
|
|
|
|
case ARM::dsub_1:
|
|
|
|
case ARM::dsub_2:
|
|
|
|
case ARM::dsub_3: {
|
2009-10-25 07:53:28 +00:00
|
|
|
// D sub-registers.
|
2010-05-06 06:36:08 +00:00
|
|
|
if (A->getSize() == 16) {
|
|
|
|
if (B == &ARM::DPR_VFP2RegClass)
|
|
|
|
return &ARM::QPR_VFP2RegClass;
|
|
|
|
if (B == &ARM::DPR_8RegClass)
|
2010-05-14 02:13:41 +00:00
|
|
|
return 0; // Do not allow coalescing!
|
2010-05-06 06:36:08 +00:00
|
|
|
return A;
|
|
|
|
}
|
|
|
|
|
2010-05-14 02:13:41 +00:00
|
|
|
if (A->getSize() == 32) {
|
|
|
|
if (B == &ARM::DPR_VFP2RegClass)
|
|
|
|
return &ARM::QQPR_VFP2RegClass;
|
|
|
|
if (B == &ARM::DPR_8RegClass)
|
|
|
|
return 0; // Do not allow coalescing!
|
|
|
|
return A;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(A->getSize() == 64 && "Expecting a QQQQ register class!");
|
|
|
|
if (B != &ARM::DPRRegClass)
|
|
|
|
return 0; // Do not allow coalescing!
|
2009-10-25 07:53:28 +00:00
|
|
|
return A;
|
|
|
|
}
|
2010-05-25 00:15:15 +00:00
|
|
|
case ARM::dsub_4:
|
|
|
|
case ARM::dsub_5:
|
|
|
|
case ARM::dsub_6:
|
|
|
|
case ARM::dsub_7: {
|
2010-05-14 02:13:41 +00:00
|
|
|
// D sub-registers of QQQQ registers.
|
|
|
|
if (A->getSize() == 64 && B == &ARM::DPRRegClass)
|
|
|
|
return A;
|
|
|
|
return 0; // Do not allow coalescing!
|
|
|
|
}
|
|
|
|
|
2010-05-25 00:15:15 +00:00
|
|
|
case ARM::qsub_0:
|
|
|
|
case ARM::qsub_1: {
|
2010-05-06 06:36:08 +00:00
|
|
|
// Q sub-registers.
|
2010-05-14 02:13:41 +00:00
|
|
|
if (A->getSize() == 32) {
|
|
|
|
if (B == &ARM::QPR_VFP2RegClass)
|
|
|
|
return &ARM::QQPR_VFP2RegClass;
|
|
|
|
if (B == &ARM::QPR_8RegClass)
|
|
|
|
return 0; // Do not allow coalescing!
|
|
|
|
return A;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(A->getSize() == 64 && "Expecting a QQQQ register class!");
|
|
|
|
if (B == &ARM::QPRRegClass)
|
|
|
|
return A;
|
|
|
|
return 0; // Do not allow coalescing!
|
|
|
|
}
|
2010-05-25 00:15:15 +00:00
|
|
|
case ARM::qsub_2:
|
|
|
|
case ARM::qsub_3: {
|
2010-05-14 02:13:41 +00:00
|
|
|
// Q sub-registers of QQQQ registers.
|
|
|
|
if (A->getSize() == 64 && B == &ARM::QPRRegClass)
|
|
|
|
return A;
|
|
|
|
return 0; // Do not allow coalescing!
|
2010-05-06 06:36:08 +00:00
|
|
|
}
|
|
|
|
}
|
2009-10-25 07:53:28 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
bool
|
2010-06-02 18:54:47 +00:00
|
|
|
ARMBaseRegisterInfo::canCombineSubRegIndices(const TargetRegisterClass *RC,
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
SmallVectorImpl<unsigned> &SubIndices,
|
|
|
|
unsigned &NewSubIdx) const {
|
|
|
|
|
|
|
|
unsigned Size = RC->getSize() * 8;
|
|
|
|
if (Size < 6)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
NewSubIdx = 0; // Whole register.
|
|
|
|
unsigned NumRegs = SubIndices.size();
|
|
|
|
if (NumRegs == 8) {
|
|
|
|
// 8 D registers -> 1 QQQQ register.
|
|
|
|
return (Size == 512 &&
|
2010-05-24 16:54:32 +00:00
|
|
|
SubIndices[0] == ARM::dsub_0 &&
|
|
|
|
SubIndices[1] == ARM::dsub_1 &&
|
|
|
|
SubIndices[2] == ARM::dsub_2 &&
|
|
|
|
SubIndices[3] == ARM::dsub_3 &&
|
|
|
|
SubIndices[4] == ARM::dsub_4 &&
|
|
|
|
SubIndices[5] == ARM::dsub_5 &&
|
|
|
|
SubIndices[6] == ARM::dsub_6 &&
|
|
|
|
SubIndices[7] == ARM::dsub_7);
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
} else if (NumRegs == 4) {
|
2010-05-24 16:54:32 +00:00
|
|
|
if (SubIndices[0] == ARM::qsub_0) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 4 Q registers -> 1 QQQQ register.
|
|
|
|
return (Size == 512 &&
|
2010-05-24 16:54:32 +00:00
|
|
|
SubIndices[1] == ARM::qsub_1 &&
|
|
|
|
SubIndices[2] == ARM::qsub_2 &&
|
|
|
|
SubIndices[3] == ARM::qsub_3);
|
|
|
|
} else if (SubIndices[0] == ARM::dsub_0) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 4 D registers -> 1 QQ register.
|
|
|
|
if (Size >= 256 &&
|
2010-05-24 16:54:32 +00:00
|
|
|
SubIndices[1] == ARM::dsub_1 &&
|
|
|
|
SubIndices[2] == ARM::dsub_2 &&
|
|
|
|
SubIndices[3] == ARM::dsub_3) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
if (Size == 512)
|
2010-05-24 16:54:32 +00:00
|
|
|
NewSubIdx = ARM::qqsub_0;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
return true;
|
|
|
|
}
|
2010-05-24 16:54:32 +00:00
|
|
|
} else if (SubIndices[0] == ARM::dsub_4) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 4 D registers -> 1 QQ register (2nd).
|
|
|
|
if (Size == 512 &&
|
2010-05-24 16:54:32 +00:00
|
|
|
SubIndices[1] == ARM::dsub_5 &&
|
|
|
|
SubIndices[2] == ARM::dsub_6 &&
|
|
|
|
SubIndices[3] == ARM::dsub_7) {
|
|
|
|
NewSubIdx = ARM::qqsub_1;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
return true;
|
|
|
|
}
|
2010-05-24 16:54:32 +00:00
|
|
|
} else if (SubIndices[0] == ARM::ssub_0) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 4 S registers -> 1 Q register.
|
|
|
|
if (Size >= 128 &&
|
2010-05-24 16:54:32 +00:00
|
|
|
SubIndices[1] == ARM::ssub_1 &&
|
|
|
|
SubIndices[2] == ARM::ssub_2 &&
|
|
|
|
SubIndices[3] == ARM::ssub_3) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
if (Size >= 256)
|
2010-05-24 16:54:32 +00:00
|
|
|
NewSubIdx = ARM::qsub_0;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (NumRegs == 2) {
|
2010-05-24 16:54:32 +00:00
|
|
|
if (SubIndices[0] == ARM::qsub_0) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 2 Q registers -> 1 QQ register.
|
2010-05-24 16:54:32 +00:00
|
|
|
if (Size >= 256 && SubIndices[1] == ARM::qsub_1) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
if (Size == 512)
|
2010-05-24 16:54:32 +00:00
|
|
|
NewSubIdx = ARM::qqsub_0;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
return true;
|
|
|
|
}
|
2010-05-24 16:54:32 +00:00
|
|
|
} else if (SubIndices[0] == ARM::qsub_2) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 2 Q registers -> 1 QQ register (2nd).
|
2010-05-24 16:54:32 +00:00
|
|
|
if (Size == 512 && SubIndices[1] == ARM::qsub_3) {
|
|
|
|
NewSubIdx = ARM::qqsub_1;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
return true;
|
|
|
|
}
|
2010-05-24 16:54:32 +00:00
|
|
|
} else if (SubIndices[0] == ARM::dsub_0) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 2 D registers -> 1 Q register.
|
2010-05-24 16:54:32 +00:00
|
|
|
if (Size >= 128 && SubIndices[1] == ARM::dsub_1) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
if (Size >= 256)
|
2010-05-24 16:54:32 +00:00
|
|
|
NewSubIdx = ARM::qsub_0;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
return true;
|
|
|
|
}
|
2010-05-24 16:54:32 +00:00
|
|
|
} else if (SubIndices[0] == ARM::dsub_2) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 2 D registers -> 1 Q register (2nd).
|
2010-05-24 16:54:32 +00:00
|
|
|
if (Size >= 256 && SubIndices[1] == ARM::dsub_3) {
|
|
|
|
NewSubIdx = ARM::qsub_1;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
return true;
|
|
|
|
}
|
2010-05-24 16:54:32 +00:00
|
|
|
} else if (SubIndices[0] == ARM::dsub_4) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 2 D registers -> 1 Q register (3rd).
|
2010-05-24 16:54:32 +00:00
|
|
|
if (Size == 512 && SubIndices[1] == ARM::dsub_5) {
|
|
|
|
NewSubIdx = ARM::qsub_2;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
return true;
|
|
|
|
}
|
2010-05-24 16:54:32 +00:00
|
|
|
} else if (SubIndices[0] == ARM::dsub_6) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 2 D registers -> 1 Q register (3rd).
|
2010-05-24 16:54:32 +00:00
|
|
|
if (Size == 512 && SubIndices[1] == ARM::dsub_7) {
|
|
|
|
NewSubIdx = ARM::qsub_3;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
return true;
|
|
|
|
}
|
2010-05-24 16:54:32 +00:00
|
|
|
} else if (SubIndices[0] == ARM::ssub_0) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 2 S registers -> 1 D register.
|
2010-05-24 16:54:32 +00:00
|
|
|
if (SubIndices[1] == ARM::ssub_1) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
if (Size >= 128)
|
2010-05-24 16:54:32 +00:00
|
|
|
NewSubIdx = ARM::dsub_0;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
return true;
|
|
|
|
}
|
2010-05-24 16:54:32 +00:00
|
|
|
} else if (SubIndices[0] == ARM::ssub_2) {
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
// 2 S registers -> 1 D register (2nd).
|
2010-05-24 16:54:32 +00:00
|
|
|
if (Size >= 128 && SubIndices[1] == ARM::ssub_3) {
|
|
|
|
NewSubIdx = ARM::dsub_1;
|
Teach two-address pass to do some coalescing while eliminating REG_SEQUENCE
instructions.
e.g.
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1027<def> = EXTRACT_SUBREG %reg1026, 6
%reg1028<def> = EXTRACT_SUBREG %reg1026<kill>, 5
...
%reg1029<def> = REG_SEQUENCE %reg1028<kill>, 5, %reg1027<kill>, 6, %reg1028, 7, %reg1027, 8, %reg1028, 9, %reg1027, 10, %reg1030<kill>, 11, %reg1032<kill>, 12
After REG_SEQUENCE is eliminated, we are left with:
%reg1026<def> = VLDMQ %reg1025<kill>, 260, pred:14, pred:%reg0
%reg1029:6<def> = EXTRACT_SUBREG %reg1026, 6
%reg1029:5<def> = EXTRACT_SUBREG %reg1026<kill>, 5
The regular coalescer will not be able to coalesce reg1026 and reg1029 because it doesn't
know how to combine sub-register indices 5 and 6. Now 2-address pass will consult the
target whether sub-registers 5 and 6 of reg1026 can be combined to into a larger
sub-register (or combined to be reg1026 itself as is the case here). If it is possible,
it will be able to replace references of reg1026 with reg1029 + the larger sub-register
index.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103835 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-14 23:21:14 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-29 20:31:52 +00:00
|
|
|
const TargetRegisterClass *
|
|
|
|
ARMBaseRegisterInfo::getPointerRegClass(unsigned Kind) const {
|
2009-09-11 19:49:06 +00:00
|
|
|
return ARM::GPRRegisterClass;
|
2009-07-08 17:28:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// getAllocationOrder - Returns the register allocation order for a specified
|
|
|
|
/// register class in the form of a pair of TargetRegisterClass iterators.
|
|
|
|
std::pair<TargetRegisterClass::iterator,TargetRegisterClass::iterator>
|
|
|
|
ARMBaseRegisterInfo::getAllocationOrder(const TargetRegisterClass *RC,
|
|
|
|
unsigned HintType, unsigned HintReg,
|
|
|
|
const MachineFunction &MF) const {
|
|
|
|
// Alternative register allocation orders when favoring even / odd registers
|
|
|
|
// of register pairs.
|
|
|
|
|
|
|
|
// No FP, R9 is available.
|
|
|
|
static const unsigned GPREven1[] = {
|
|
|
|
ARM::R0, ARM::R2, ARM::R4, ARM::R6, ARM::R8, ARM::R10,
|
|
|
|
ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R7,
|
|
|
|
ARM::R9, ARM::R11
|
|
|
|
};
|
|
|
|
static const unsigned GPROdd1[] = {
|
|
|
|
ARM::R1, ARM::R3, ARM::R5, ARM::R7, ARM::R9, ARM::R11,
|
|
|
|
ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6,
|
|
|
|
ARM::R8, ARM::R10
|
|
|
|
};
|
|
|
|
|
|
|
|
// FP is R7, R9 is available.
|
|
|
|
static const unsigned GPREven2[] = {
|
|
|
|
ARM::R0, ARM::R2, ARM::R4, ARM::R8, ARM::R10,
|
|
|
|
ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R6,
|
|
|
|
ARM::R9, ARM::R11
|
|
|
|
};
|
|
|
|
static const unsigned GPROdd2[] = {
|
|
|
|
ARM::R1, ARM::R3, ARM::R5, ARM::R9, ARM::R11,
|
|
|
|
ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6,
|
|
|
|
ARM::R8, ARM::R10
|
|
|
|
};
|
|
|
|
|
|
|
|
// FP is R11, R9 is available.
|
|
|
|
static const unsigned GPREven3[] = {
|
|
|
|
ARM::R0, ARM::R2, ARM::R4, ARM::R6, ARM::R8,
|
|
|
|
ARM::R1, ARM::R3, ARM::R10,ARM::R12,ARM::LR, ARM::R5, ARM::R7,
|
|
|
|
ARM::R9
|
|
|
|
};
|
|
|
|
static const unsigned GPROdd3[] = {
|
|
|
|
ARM::R1, ARM::R3, ARM::R5, ARM::R6, ARM::R9,
|
|
|
|
ARM::R0, ARM::R2, ARM::R10,ARM::R12,ARM::LR, ARM::R4, ARM::R7,
|
|
|
|
ARM::R8
|
|
|
|
};
|
|
|
|
|
|
|
|
// No FP, R9 is not available.
|
|
|
|
static const unsigned GPREven4[] = {
|
|
|
|
ARM::R0, ARM::R2, ARM::R4, ARM::R6, ARM::R10,
|
|
|
|
ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R7, ARM::R8,
|
|
|
|
ARM::R11
|
|
|
|
};
|
|
|
|
static const unsigned GPROdd4[] = {
|
|
|
|
ARM::R1, ARM::R3, ARM::R5, ARM::R7, ARM::R11,
|
|
|
|
ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6, ARM::R8,
|
|
|
|
ARM::R10
|
|
|
|
};
|
|
|
|
|
|
|
|
// FP is R7, R9 is not available.
|
|
|
|
static const unsigned GPREven5[] = {
|
|
|
|
ARM::R0, ARM::R2, ARM::R4, ARM::R10,
|
|
|
|
ARM::R1, ARM::R3, ARM::R12,ARM::LR, ARM::R5, ARM::R6, ARM::R8,
|
|
|
|
ARM::R11
|
|
|
|
};
|
|
|
|
static const unsigned GPROdd5[] = {
|
|
|
|
ARM::R1, ARM::R3, ARM::R5, ARM::R11,
|
|
|
|
ARM::R0, ARM::R2, ARM::R12,ARM::LR, ARM::R4, ARM::R6, ARM::R8,
|
|
|
|
ARM::R10
|
|
|
|
};
|
|
|
|
|
|
|
|
// FP is R11, R9 is not available.
|
|
|
|
static const unsigned GPREven6[] = {
|
|
|
|
ARM::R0, ARM::R2, ARM::R4, ARM::R6,
|
|
|
|
ARM::R1, ARM::R3, ARM::R10,ARM::R12,ARM::LR, ARM::R5, ARM::R7, ARM::R8
|
|
|
|
};
|
|
|
|
static const unsigned GPROdd6[] = {
|
|
|
|
ARM::R1, ARM::R3, ARM::R5, ARM::R7,
|
|
|
|
ARM::R0, ARM::R2, ARM::R10,ARM::R12,ARM::LR, ARM::R4, ARM::R6, ARM::R8
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
if (HintType == ARMRI::RegPairEven) {
|
|
|
|
if (isPhysicalRegister(HintReg) && getRegisterPairEven(HintReg, MF) == 0)
|
|
|
|
// It's no longer possible to fulfill this hint. Return the default
|
|
|
|
// allocation order.
|
|
|
|
return std::make_pair(RC->allocation_order_begin(MF),
|
|
|
|
RC->allocation_order_end(MF));
|
|
|
|
|
2010-08-10 19:30:19 +00:00
|
|
|
if (!hasFP(MF)) {
|
2009-07-08 17:28:55 +00:00
|
|
|
if (!STI.isR9Reserved())
|
|
|
|
return std::make_pair(GPREven1,
|
|
|
|
GPREven1 + (sizeof(GPREven1)/sizeof(unsigned)));
|
|
|
|
else
|
|
|
|
return std::make_pair(GPREven4,
|
|
|
|
GPREven4 + (sizeof(GPREven4)/sizeof(unsigned)));
|
|
|
|
} else if (FramePtr == ARM::R7) {
|
|
|
|
if (!STI.isR9Reserved())
|
|
|
|
return std::make_pair(GPREven2,
|
|
|
|
GPREven2 + (sizeof(GPREven2)/sizeof(unsigned)));
|
|
|
|
else
|
|
|
|
return std::make_pair(GPREven5,
|
|
|
|
GPREven5 + (sizeof(GPREven5)/sizeof(unsigned)));
|
|
|
|
} else { // FramePtr == ARM::R11
|
|
|
|
if (!STI.isR9Reserved())
|
|
|
|
return std::make_pair(GPREven3,
|
|
|
|
GPREven3 + (sizeof(GPREven3)/sizeof(unsigned)));
|
|
|
|
else
|
|
|
|
return std::make_pair(GPREven6,
|
|
|
|
GPREven6 + (sizeof(GPREven6)/sizeof(unsigned)));
|
|
|
|
}
|
|
|
|
} else if (HintType == ARMRI::RegPairOdd) {
|
|
|
|
if (isPhysicalRegister(HintReg) && getRegisterPairOdd(HintReg, MF) == 0)
|
|
|
|
// It's no longer possible to fulfill this hint. Return the default
|
|
|
|
// allocation order.
|
|
|
|
return std::make_pair(RC->allocation_order_begin(MF),
|
|
|
|
RC->allocation_order_end(MF));
|
|
|
|
|
2010-08-10 19:30:19 +00:00
|
|
|
if (!hasFP(MF)) {
|
2009-07-08 17:28:55 +00:00
|
|
|
if (!STI.isR9Reserved())
|
|
|
|
return std::make_pair(GPROdd1,
|
|
|
|
GPROdd1 + (sizeof(GPROdd1)/sizeof(unsigned)));
|
|
|
|
else
|
|
|
|
return std::make_pair(GPROdd4,
|
|
|
|
GPROdd4 + (sizeof(GPROdd4)/sizeof(unsigned)));
|
|
|
|
} else if (FramePtr == ARM::R7) {
|
|
|
|
if (!STI.isR9Reserved())
|
|
|
|
return std::make_pair(GPROdd2,
|
|
|
|
GPROdd2 + (sizeof(GPROdd2)/sizeof(unsigned)));
|
|
|
|
else
|
|
|
|
return std::make_pair(GPROdd5,
|
|
|
|
GPROdd5 + (sizeof(GPROdd5)/sizeof(unsigned)));
|
|
|
|
} else { // FramePtr == ARM::R11
|
|
|
|
if (!STI.isR9Reserved())
|
|
|
|
return std::make_pair(GPROdd3,
|
|
|
|
GPROdd3 + (sizeof(GPROdd3)/sizeof(unsigned)));
|
|
|
|
else
|
|
|
|
return std::make_pair(GPROdd6,
|
|
|
|
GPROdd6 + (sizeof(GPROdd6)/sizeof(unsigned)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return std::make_pair(RC->allocation_order_begin(MF),
|
|
|
|
RC->allocation_order_end(MF));
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ResolveRegAllocHint - Resolves the specified register allocation hint
|
|
|
|
/// to a physical register. Returns the physical register if it is successful.
|
|
|
|
unsigned
|
|
|
|
ARMBaseRegisterInfo::ResolveRegAllocHint(unsigned Type, unsigned Reg,
|
|
|
|
const MachineFunction &MF) const {
|
|
|
|
if (Reg == 0 || !isPhysicalRegister(Reg))
|
|
|
|
return 0;
|
|
|
|
if (Type == 0)
|
|
|
|
return Reg;
|
|
|
|
else if (Type == (unsigned)ARMRI::RegPairOdd)
|
|
|
|
// Odd register.
|
|
|
|
return getRegisterPairOdd(Reg, MF);
|
|
|
|
else if (Type == (unsigned)ARMRI::RegPairEven)
|
|
|
|
// Even register.
|
|
|
|
return getRegisterPairEven(Reg, MF);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ARMBaseRegisterInfo::UpdateRegAllocHint(unsigned Reg, unsigned NewReg,
|
|
|
|
MachineFunction &MF) const {
|
|
|
|
MachineRegisterInfo *MRI = &MF.getRegInfo();
|
|
|
|
std::pair<unsigned, unsigned> Hint = MRI->getRegAllocationHint(Reg);
|
|
|
|
if ((Hint.first == (unsigned)ARMRI::RegPairOdd ||
|
|
|
|
Hint.first == (unsigned)ARMRI::RegPairEven) &&
|
|
|
|
Hint.second && TargetRegisterInfo::isVirtualRegister(Hint.second)) {
|
|
|
|
// If 'Reg' is one of the even / odd register pair and it's now changed
|
|
|
|
// (e.g. coalesced) into a different register. The other register of the
|
|
|
|
// pair allocation hint must be updated to reflect the relationship
|
|
|
|
// change.
|
|
|
|
unsigned OtherReg = Hint.second;
|
|
|
|
Hint = MRI->getRegAllocationHint(OtherReg);
|
|
|
|
if (Hint.second == Reg)
|
|
|
|
// Make sure the pair has not already divorced.
|
|
|
|
MRI->setRegAllocationHint(OtherReg, Hint.first, NewReg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// hasFP - Return true if the specified function should have a dedicated frame
|
|
|
|
/// pointer register. This is true if the function has variable sized allocas
|
|
|
|
/// or if frame pointer elimination is disabled.
|
|
|
|
///
|
|
|
|
bool ARMBaseRegisterInfo::hasFP(const MachineFunction &MF) const {
|
2010-08-10 19:30:19 +00:00
|
|
|
// Mac OS X requires FP not to be clobbered for backtracing purpose.
|
|
|
|
if (STI.isTargetDarwin())
|
|
|
|
return true;
|
|
|
|
|
2009-07-08 17:28:55 +00:00
|
|
|
const MachineFrameInfo *MFI = MF.getFrameInfo();
|
2010-08-09 22:32:45 +00:00
|
|
|
// Always eliminate non-leaf frame pointers.
|
|
|
|
return ((DisableFramePointerElim(MF) && MFI->hasCalls()) ||
|
2009-10-27 22:45:39 +00:00
|
|
|
needsStackRealignment(MF) ||
|
2009-07-08 17:28:55 +00:00
|
|
|
MFI->hasVarSizedObjects() ||
|
|
|
|
MFI->isFrameAddressTaken());
|
|
|
|
}
|
|
|
|
|
2010-01-19 18:31:11 +00:00
|
|
|
bool ARMBaseRegisterInfo::canRealignStack(const MachineFunction &MF) const {
|
|
|
|
const MachineFrameInfo *MFI = MF.getFrameInfo();
|
|
|
|
const ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
|
|
|
|
return (RealignStack &&
|
|
|
|
!AFI->isThumb1OnlyFunction() &&
|
|
|
|
!MFI->hasVarSizedObjects());
|
|
|
|
}
|
|
|
|
|
2009-10-27 22:45:39 +00:00
|
|
|
bool ARMBaseRegisterInfo::
|
|
|
|
needsStackRealignment(const MachineFunction &MF) const {
|
|
|
|
const MachineFrameInfo *MFI = MF.getFrameInfo();
|
2010-07-17 00:27:24 +00:00
|
|
|
const Function *F = MF.getFunction();
|
2009-10-27 22:45:39 +00:00
|
|
|
const ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
|
2009-11-09 22:32:03 +00:00
|
|
|
unsigned StackAlign = MF.getTarget().getFrameInfo()->getStackAlignment();
|
2010-07-17 00:33:04 +00:00
|
|
|
bool requiresRealignment = ((MFI->getMaxAlignment() > StackAlign) ||
|
|
|
|
F->hasFnAttr(Attribute::StackAlignment));
|
2010-07-17 00:27:24 +00:00
|
|
|
|
|
|
|
// FIXME: Currently we don't support stack realignment for functions with
|
|
|
|
// variable-sized allocas.
|
|
|
|
// FIXME: It's more complicated than this...
|
|
|
|
if (0 && requiresRealignment && MFI->hasVarSizedObjects())
|
|
|
|
report_fatal_error(
|
|
|
|
"Stack realignment in presense of dynamic allocas is not supported");
|
|
|
|
|
|
|
|
// FIXME: This probably isn't the right place for this.
|
|
|
|
if (0 && requiresRealignment && AFI->isThumb1OnlyFunction())
|
|
|
|
report_fatal_error(
|
|
|
|
"Stack realignment in thumb1 functions is not supported");
|
|
|
|
|
|
|
|
return requiresRealignment && canRealignStack(MF);
|
2009-10-27 22:45:39 +00:00
|
|
|
}
|
|
|
|
|
2010-01-06 23:54:42 +00:00
|
|
|
bool ARMBaseRegisterInfo::
|
|
|
|
cannotEliminateFrame(const MachineFunction &MF) const {
|
2009-08-14 20:48:13 +00:00
|
|
|
const MachineFrameInfo *MFI = MF.getFrameInfo();
|
2010-05-14 21:14:32 +00:00
|
|
|
if (DisableFramePointerElim(MF) && MFI->adjustsStack())
|
2009-08-14 20:48:13 +00:00
|
|
|
return true;
|
2009-11-08 00:27:19 +00:00
|
|
|
return MFI->hasVarSizedObjects() || MFI->isFrameAddressTaken()
|
|
|
|
|| needsStackRealignment(MF);
|
2009-08-14 20:48:13 +00:00
|
|
|
}
|
|
|
|
|
2009-07-28 06:24:12 +00:00
|
|
|
/// estimateStackSize - Estimate and return the size of the frame.
|
2010-02-24 22:43:17 +00:00
|
|
|
static unsigned estimateStackSize(MachineFunction &MF) {
|
2009-07-08 17:28:55 +00:00
|
|
|
const MachineFrameInfo *FFI = MF.getFrameInfo();
|
|
|
|
int Offset = 0;
|
|
|
|
for (int i = FFI->getObjectIndexBegin(); i != 0; ++i) {
|
|
|
|
int FixedOff = -FFI->getObjectOffset(i);
|
|
|
|
if (FixedOff > Offset) Offset = FixedOff;
|
|
|
|
}
|
|
|
|
for (unsigned i = 0, e = FFI->getObjectIndexEnd(); i != e; ++i) {
|
|
|
|
if (FFI->isDeadObjectIndex(i))
|
|
|
|
continue;
|
|
|
|
Offset += FFI->getObjectSize(i);
|
|
|
|
unsigned Align = FFI->getObjectAlignment(i);
|
|
|
|
// Adjust to alignment boundary
|
|
|
|
Offset = (Offset+Align-1)/Align*Align;
|
|
|
|
}
|
|
|
|
return (unsigned)Offset;
|
|
|
|
}
|
|
|
|
|
2009-07-28 06:24:12 +00:00
|
|
|
/// estimateRSStackSizeLimit - Look at each instruction that references stack
|
|
|
|
/// frames and return the stack size limit beyond which some of these
|
2010-01-06 23:45:18 +00:00
|
|
|
/// instructions will require a scratch register during their expansion later.
|
2009-07-30 23:29:25 +00:00
|
|
|
unsigned
|
|
|
|
ARMBaseRegisterInfo::estimateRSStackSizeLimit(MachineFunction &MF) const {
|
2010-08-10 19:30:19 +00:00
|
|
|
const ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
|
2009-07-28 06:24:12 +00:00
|
|
|
unsigned Limit = (1 << 12) - 1;
|
2009-07-28 18:48:43 +00:00
|
|
|
for (MachineFunction::iterator BB = MF.begin(),E = MF.end(); BB != E; ++BB) {
|
|
|
|
for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end();
|
|
|
|
I != E; ++I) {
|
|
|
|
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
|
|
|
|
if (!I->getOperand(i).isFI()) continue;
|
2010-06-18 20:59:25 +00:00
|
|
|
|
|
|
|
// When using ADDri to get the address of a stack object, 255 is the
|
|
|
|
// largest offset guaranteed to fit in the immediate offset.
|
|
|
|
if (I->getOpcode() == ARM::ADDri) {
|
|
|
|
Limit = std::min(Limit, (1U << 8) - 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise check the addressing mode.
|
2010-05-17 23:29:23 +00:00
|
|
|
switch (I->getDesc().TSFlags & ARMII::AddrModeMask) {
|
|
|
|
case ARMII::AddrMode3:
|
|
|
|
case ARMII::AddrModeT2_i8:
|
|
|
|
Limit = std::min(Limit, (1U << 8) - 1);
|
|
|
|
break;
|
|
|
|
case ARMII::AddrMode5:
|
|
|
|
case ARMII::AddrModeT2_i8s4:
|
2009-07-28 18:48:43 +00:00
|
|
|
Limit = std::min(Limit, ((1U << 8) - 1) * 4);
|
2010-05-17 23:29:23 +00:00
|
|
|
break;
|
|
|
|
case ARMII::AddrModeT2_i12:
|
2010-08-10 19:30:19 +00:00
|
|
|
// i12 supports only positive offset so these will be converted to
|
|
|
|
// i8 opcodes. See llvm::rewriteT2FrameIndex.
|
|
|
|
if (hasFP(MF) && AFI->hasStackFrame())
|
|
|
|
Limit = std::min(Limit, (1U << 8) - 1);
|
2010-05-17 23:29:23 +00:00
|
|
|
break;
|
|
|
|
case ARMII::AddrMode6:
|
|
|
|
// Addressing mode 6 (load/store) instructions can't encode an
|
|
|
|
// immediate offset for stack references.
|
2010-01-06 23:45:18 +00:00
|
|
|
return 0;
|
2010-05-17 23:29:23 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2009-07-28 18:48:43 +00:00
|
|
|
break; // At most one FI per instruction
|
|
|
|
}
|
2009-07-28 06:24:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Limit;
|
|
|
|
}
|
|
|
|
|
2010-07-22 21:14:33 +00:00
|
|
|
static unsigned GetFunctionSizeInBytes(const MachineFunction &MF,
|
|
|
|
const ARMBaseInstrInfo &TII) {
|
|
|
|
unsigned FnSize = 0;
|
|
|
|
for (MachineFunction::const_iterator MBBI = MF.begin(), E = MF.end();
|
|
|
|
MBBI != E; ++MBBI) {
|
|
|
|
const MachineBasicBlock &MBB = *MBBI;
|
|
|
|
for (MachineBasicBlock::const_iterator I = MBB.begin(),E = MBB.end();
|
|
|
|
I != E; ++I)
|
|
|
|
FnSize += TII.GetInstSizeInBytes(I);
|
|
|
|
}
|
|
|
|
return FnSize;
|
|
|
|
}
|
|
|
|
|
2009-07-08 17:28:55 +00:00
|
|
|
void
|
|
|
|
ARMBaseRegisterInfo::processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
|
2010-01-06 23:54:42 +00:00
|
|
|
RegScavenger *RS) const {
|
2009-07-08 17:28:55 +00:00
|
|
|
// This tells PEI to spill the FP as if it is any other callee-save register
|
|
|
|
// to take advantage the eliminateFrameIndex machinery. This also ensures it
|
|
|
|
// is spilled in the order specified by getCalleeSavedRegs() to make it easier
|
|
|
|
// to combine multiple loads / stores.
|
|
|
|
bool CanEliminateFrame = true;
|
|
|
|
bool CS1Spilled = false;
|
|
|
|
bool LRSpilled = false;
|
|
|
|
unsigned NumGPRSpills = 0;
|
|
|
|
SmallVector<unsigned, 4> UnspilledCS1GPRs;
|
|
|
|
SmallVector<unsigned, 4> UnspilledCS2GPRs;
|
|
|
|
ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
|
2010-07-09 20:27:06 +00:00
|
|
|
MachineFrameInfo *MFI = MF.getFrameInfo();
|
2009-07-08 17:28:55 +00:00
|
|
|
|
2009-12-06 22:39:50 +00:00
|
|
|
// Spill R4 if Thumb2 function requires stack realignment - it will be used as
|
|
|
|
// scratch register.
|
|
|
|
// FIXME: It will be better just to find spare register here.
|
|
|
|
if (needsStackRealignment(MF) &&
|
|
|
|
AFI->isThumb2Function())
|
|
|
|
MF.getRegInfo().setPhysRegUsed(ARM::R4);
|
|
|
|
|
2010-03-10 20:01:30 +00:00
|
|
|
// Spill LR if Thumb1 function uses variable length argument lists.
|
|
|
|
if (AFI->isThumb1OnlyFunction() && AFI->getVarArgsRegSaveSize() > 0)
|
|
|
|
MF.getRegInfo().setPhysRegUsed(ARM::LR);
|
|
|
|
|
2009-07-08 17:28:55 +00:00
|
|
|
// Don't spill FP if the frame can be eliminated. This is determined
|
|
|
|
// by scanning the callee-save registers to see if any is used.
|
|
|
|
const unsigned *CSRegs = getCalleeSavedRegs();
|
|
|
|
for (unsigned i = 0; CSRegs[i]; ++i) {
|
|
|
|
unsigned Reg = CSRegs[i];
|
|
|
|
bool Spilled = false;
|
|
|
|
if (MF.getRegInfo().isPhysRegUsed(Reg)) {
|
|
|
|
AFI->setCSRegisterIsSpilled(Reg);
|
|
|
|
Spilled = true;
|
|
|
|
CanEliminateFrame = false;
|
|
|
|
} else {
|
|
|
|
// Check alias registers too.
|
|
|
|
for (const unsigned *Aliases = getAliasSet(Reg); *Aliases; ++Aliases) {
|
|
|
|
if (MF.getRegInfo().isPhysRegUsed(*Aliases)) {
|
|
|
|
Spilled = true;
|
|
|
|
CanEliminateFrame = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-02 17:54:50 +00:00
|
|
|
if (!ARM::GPRRegisterClass->contains(Reg))
|
|
|
|
continue;
|
2009-07-08 17:28:55 +00:00
|
|
|
|
2010-06-02 17:54:50 +00:00
|
|
|
if (Spilled) {
|
|
|
|
NumGPRSpills++;
|
2009-07-08 17:28:55 +00:00
|
|
|
|
2010-06-02 17:54:50 +00:00
|
|
|
if (!STI.isTargetDarwin()) {
|
|
|
|
if (Reg == ARM::LR)
|
2009-07-08 17:28:55 +00:00
|
|
|
LRSpilled = true;
|
2010-06-02 17:54:50 +00:00
|
|
|
CS1Spilled = true;
|
|
|
|
continue;
|
|
|
|
}
|
2009-07-08 17:28:55 +00:00
|
|
|
|
2010-06-02 17:54:50 +00:00
|
|
|
// Keep track if LR and any of R4, R5, R6, and R7 is spilled.
|
|
|
|
switch (Reg) {
|
|
|
|
case ARM::LR:
|
|
|
|
LRSpilled = true;
|
|
|
|
// Fallthrough
|
|
|
|
case ARM::R4:
|
|
|
|
case ARM::R5:
|
|
|
|
case ARM::R6:
|
|
|
|
case ARM::R7:
|
|
|
|
CS1Spilled = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!STI.isTargetDarwin()) {
|
|
|
|
UnspilledCS1GPRs.push_back(Reg);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (Reg) {
|
|
|
|
case ARM::R4:
|
|
|
|
case ARM::R5:
|
|
|
|
case ARM::R6:
|
|
|
|
case ARM::R7:
|
|
|
|
case ARM::LR:
|
|
|
|
UnspilledCS1GPRs.push_back(Reg);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
UnspilledCS2GPRs.push_back(Reg);
|
|
|
|
break;
|
2009-07-08 17:28:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ForceLRSpill = false;
|
2009-07-08 23:10:31 +00:00
|
|
|
if (!LRSpilled && AFI->isThumb1OnlyFunction()) {
|
2010-07-22 21:14:33 +00:00
|
|
|
unsigned FnSize = GetFunctionSizeInBytes(MF, TII);
|
2009-07-08 17:28:55 +00:00
|
|
|
// Force LR to be spilled if the Thumb function size is > 2048. This enables
|
|
|
|
// use of BL to implement far jump. If it turns out that it's not needed
|
|
|
|
// then the branch fix up path will undo it.
|
|
|
|
if (FnSize >= (1 << 11)) {
|
|
|
|
CanEliminateFrame = false;
|
|
|
|
ForceLRSpill = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-24 22:43:17 +00:00
|
|
|
// If any of the stack slot references may be out of range of an immediate
|
|
|
|
// offset, make sure a register (or a spill slot) is available for the
|
|
|
|
// register scavenger. Note that if we're indexing off the frame pointer, the
|
|
|
|
// effective stack size is 4 bytes larger since the FP points to the stack
|
2010-07-09 20:27:06 +00:00
|
|
|
// slot of the previous FP. Also, if we have variable sized objects in the
|
|
|
|
// function, stack slot references will often be negative, and some of
|
|
|
|
// our instructions are positive-offset only, so conservatively consider
|
2010-08-04 22:46:09 +00:00
|
|
|
// that case to want a spill slot (or register) as well. Similarly, if
|
|
|
|
// the function adjusts the stack pointer during execution and the
|
|
|
|
// adjustments aren't already part of our stack size estimate, our offset
|
|
|
|
// calculations may be off, so be conservative.
|
2010-07-09 20:27:06 +00:00
|
|
|
// FIXME: We could add logic to be more precise about negative offsets
|
|
|
|
// and which instructions will need a scratch register for them. Is it
|
|
|
|
// worth the effort and added fragility?
|
2010-07-10 12:06:22 +00:00
|
|
|
bool BigStack =
|
2010-08-10 19:30:19 +00:00
|
|
|
(RS &&
|
|
|
|
(estimateStackSize(MF) + ((hasFP(MF) && AFI->hasStackFrame()) ? 4:0) >=
|
|
|
|
estimateRSStackSizeLimit(MF)))
|
2010-08-05 03:04:21 +00:00
|
|
|
|| MFI->hasVarSizedObjects()
|
|
|
|
|| (MFI->adjustsStack() && !canSimplifyCallFramePseudos(MF));
|
2010-02-24 22:43:17 +00:00
|
|
|
|
2009-07-08 17:28:55 +00:00
|
|
|
bool ExtraCSSpill = false;
|
2010-02-24 22:43:17 +00:00
|
|
|
if (BigStack || !CanEliminateFrame || cannotEliminateFrame(MF)) {
|
2009-07-08 17:28:55 +00:00
|
|
|
AFI->setHasStackFrame(true);
|
|
|
|
|
|
|
|
// If LR is not spilled, but at least one of R4, R5, R6, and R7 is spilled.
|
|
|
|
// Spill LR as well so we can fold BX_RET to the registers restore (LDM).
|
|
|
|
if (!LRSpilled && CS1Spilled) {
|
|
|
|
MF.getRegInfo().setPhysRegUsed(ARM::LR);
|
|
|
|
AFI->setCSRegisterIsSpilled(ARM::LR);
|
|
|
|
NumGPRSpills++;
|
|
|
|
UnspilledCS1GPRs.erase(std::find(UnspilledCS1GPRs.begin(),
|
|
|
|
UnspilledCS1GPRs.end(), (unsigned)ARM::LR));
|
|
|
|
ForceLRSpill = false;
|
|
|
|
ExtraCSSpill = true;
|
|
|
|
}
|
|
|
|
|
2010-08-10 19:30:19 +00:00
|
|
|
if (hasFP(MF)) {
|
2009-07-08 17:28:55 +00:00
|
|
|
MF.getRegInfo().setPhysRegUsed(FramePtr);
|
|
|
|
NumGPRSpills++;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If stack and double are 8-byte aligned and we are spilling an odd number
|
|
|
|
// of GPRs. Spill one extra callee save GPR so we won't have to pad between
|
|
|
|
// the integer and double callee save areas.
|
|
|
|
unsigned TargetAlign = MF.getTarget().getFrameInfo()->getStackAlignment();
|
|
|
|
if (TargetAlign == 8 && (NumGPRSpills & 1)) {
|
|
|
|
if (CS1Spilled && !UnspilledCS1GPRs.empty()) {
|
|
|
|
for (unsigned i = 0, e = UnspilledCS1GPRs.size(); i != e; ++i) {
|
|
|
|
unsigned Reg = UnspilledCS1GPRs[i];
|
2009-07-08 23:10:31 +00:00
|
|
|
// Don't spill high register if the function is thumb1
|
|
|
|
if (!AFI->isThumb1OnlyFunction() ||
|
2009-07-08 17:28:55 +00:00
|
|
|
isARMLowRegister(Reg) || Reg == ARM::LR) {
|
|
|
|
MF.getRegInfo().setPhysRegUsed(Reg);
|
|
|
|
AFI->setCSRegisterIsSpilled(Reg);
|
|
|
|
if (!isReservedReg(MF, Reg))
|
|
|
|
ExtraCSSpill = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (!UnspilledCS2GPRs.empty() &&
|
2009-07-08 23:10:31 +00:00
|
|
|
!AFI->isThumb1OnlyFunction()) {
|
2009-07-08 17:28:55 +00:00
|
|
|
unsigned Reg = UnspilledCS2GPRs.front();
|
|
|
|
MF.getRegInfo().setPhysRegUsed(Reg);
|
|
|
|
AFI->setCSRegisterIsSpilled(Reg);
|
|
|
|
if (!isReservedReg(MF, Reg))
|
|
|
|
ExtraCSSpill = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Estimate if we might need to scavenge a register at some point in order
|
|
|
|
// to materialize a stack offset. If so, either spill one additional
|
|
|
|
// callee-saved register or reserve a special spill slot to facilitate
|
Start of revamping the register scavenging in PEI. ARM Thumb1 is the driving
interest for this, as it currently reserves a register rather than using
the scavenger for matierializing constants as needed.
Instead of scavenging registers on the fly while eliminating frame indices,
new virtual registers are created, and then a scavenged collectively in a
post-pass over the function. This isolates the bits that need to interact
with the scavenger, and sets the stage for more intelligent use, and reuse,
of scavenged registers.
For the time being, this is disabled by default. Once the bugs are worked out,
the current scavenging calls in replaceFrameIndices() will be removed and
the post-pass scavenging will be the default. Until then,
-enable-frame-index-scavenging enables the new code. Currently, only the
Thumb1 back end is set up to use it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@82734 91177308-0d34-0410-b5e6-96231b3b80d8
2009-09-24 23:52:18 +00:00
|
|
|
// register scavenging. Thumb1 needs a spill slot for stack pointer
|
|
|
|
// adjustments also, even when the frame itself is small.
|
2010-02-24 22:43:17 +00:00
|
|
|
if (BigStack && !ExtraCSSpill) {
|
|
|
|
// If any non-reserved CS register isn't spilled, just spill one or two
|
|
|
|
// extra. That should take care of it!
|
|
|
|
unsigned NumExtras = TargetAlign / 4;
|
|
|
|
SmallVector<unsigned, 2> Extras;
|
|
|
|
while (NumExtras && !UnspilledCS1GPRs.empty()) {
|
|
|
|
unsigned Reg = UnspilledCS1GPRs.back();
|
|
|
|
UnspilledCS1GPRs.pop_back();
|
2010-05-13 19:58:24 +00:00
|
|
|
if (!isReservedReg(MF, Reg) &&
|
|
|
|
(!AFI->isThumb1OnlyFunction() || isARMLowRegister(Reg) ||
|
|
|
|
Reg == ARM::LR)) {
|
2010-02-24 22:43:17 +00:00
|
|
|
Extras.push_back(Reg);
|
|
|
|
NumExtras--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// For non-Thumb1 functions, also check for hi-reg CS registers
|
|
|
|
if (!AFI->isThumb1OnlyFunction()) {
|
|
|
|
while (NumExtras && !UnspilledCS2GPRs.empty()) {
|
|
|
|
unsigned Reg = UnspilledCS2GPRs.back();
|
|
|
|
UnspilledCS2GPRs.pop_back();
|
2009-07-08 17:28:55 +00:00
|
|
|
if (!isReservedReg(MF, Reg)) {
|
|
|
|
Extras.push_back(Reg);
|
|
|
|
NumExtras--;
|
|
|
|
}
|
|
|
|
}
|
2010-02-24 22:43:17 +00:00
|
|
|
}
|
|
|
|
if (Extras.size() && NumExtras == 0) {
|
|
|
|
for (unsigned i = 0, e = Extras.size(); i != e; ++i) {
|
|
|
|
MF.getRegInfo().setPhysRegUsed(Extras[i]);
|
|
|
|
AFI->setCSRegisterIsSpilled(Extras[i]);
|
2009-07-08 17:28:55 +00:00
|
|
|
}
|
2010-02-24 22:43:17 +00:00
|
|
|
} else if (!AFI->isThumb1OnlyFunction()) {
|
|
|
|
// note: Thumb1 functions spill to R12, not the stack. Reserve a slot
|
|
|
|
// closest to SP or frame pointer.
|
|
|
|
const TargetRegisterClass *RC = ARM::GPRRegisterClass;
|
|
|
|
RS->setScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
|
|
|
|
RC->getAlignment(),
|
|
|
|
false));
|
2009-07-08 17:28:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ForceLRSpill) {
|
|
|
|
MF.getRegInfo().setPhysRegUsed(ARM::LR);
|
|
|
|
AFI->setCSRegisterIsSpilled(ARM::LR);
|
|
|
|
AFI->setLRIsSpilledForFarJump(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned ARMBaseRegisterInfo::getRARegister() const {
|
|
|
|
return ARM::LR;
|
|
|
|
}
|
|
|
|
|
2009-11-12 20:49:22 +00:00
|
|
|
unsigned
|
|
|
|
ARMBaseRegisterInfo::getFrameRegister(const MachineFunction &MF) const {
|
2010-08-10 19:30:19 +00:00
|
|
|
if (hasFP(MF))
|
2009-07-08 17:28:55 +00:00
|
|
|
return FramePtr;
|
|
|
|
return ARM::SP;
|
|
|
|
}
|
|
|
|
|
2010-08-05 19:27:37 +00:00
|
|
|
// Provide a base+offset reference to an FI slot for debug info. It's the
|
|
|
|
// same as what we use for resolving the code-gen references for now.
|
|
|
|
// FIXME: This can go wrong when references are SP-relative and simple call
|
|
|
|
// frames aren't used.
|
2009-11-22 02:32:29 +00:00
|
|
|
int
|
2010-01-26 23:15:09 +00:00
|
|
|
ARMBaseRegisterInfo::getFrameIndexReference(const MachineFunction &MF, int FI,
|
2009-11-22 02:32:29 +00:00
|
|
|
unsigned &FrameReg) const {
|
2010-08-05 19:27:37 +00:00
|
|
|
return ResolveFrameIndexReference(MF, FI, FrameReg, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ARMBaseRegisterInfo::ResolveFrameIndexReference(const MachineFunction &MF,
|
|
|
|
int FI,
|
|
|
|
unsigned &FrameReg,
|
|
|
|
int SPAdj) const {
|
2009-11-22 02:32:29 +00:00
|
|
|
const MachineFrameInfo *MFI = MF.getFrameInfo();
|
2010-01-26 23:15:09 +00:00
|
|
|
const ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
|
2009-11-22 02:32:29 +00:00
|
|
|
int Offset = MFI->getObjectOffset(FI) + MFI->getStackSize();
|
2010-08-05 19:27:37 +00:00
|
|
|
int FPOffset = Offset - AFI->getFramePtrSpillOffset();
|
2009-11-22 02:32:29 +00:00
|
|
|
bool isFixed = MFI->isFixedObjectIndex(FI);
|
|
|
|
|
2009-11-22 20:05:32 +00:00
|
|
|
FrameReg = ARM::SP;
|
2010-08-05 19:27:37 +00:00
|
|
|
Offset += SPAdj;
|
2009-11-22 02:32:29 +00:00
|
|
|
if (AFI->isGPRCalleeSavedArea1Frame(FI))
|
2010-08-05 19:27:37 +00:00
|
|
|
return Offset - AFI->getGPRCalleeSavedArea1Offset();
|
2009-11-22 02:32:29 +00:00
|
|
|
else if (AFI->isGPRCalleeSavedArea2Frame(FI))
|
2010-08-05 19:27:37 +00:00
|
|
|
return Offset - AFI->getGPRCalleeSavedArea2Offset();
|
2009-11-22 02:32:29 +00:00
|
|
|
else if (AFI->isDPRCalleeSavedAreaFrame(FI))
|
2010-08-05 19:27:37 +00:00
|
|
|
return Offset - AFI->getDPRCalleeSavedAreaOffset();
|
|
|
|
|
|
|
|
// When dynamically realigning the stack, use the frame pointer for
|
|
|
|
// parameters, and the stack pointer for locals.
|
|
|
|
if (needsStackRealignment(MF)) {
|
2009-11-22 02:32:29 +00:00
|
|
|
assert (hasFP(MF) && "dynamic stack realignment without a FP!");
|
|
|
|
if (isFixed) {
|
|
|
|
FrameReg = getFrameRegister(MF);
|
2010-08-05 19:27:37 +00:00
|
|
|
Offset = FPOffset;
|
2009-11-22 02:32:29 +00:00
|
|
|
}
|
2010-08-05 19:27:37 +00:00
|
|
|
return Offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there is a frame pointer, use it when we can.
|
|
|
|
if (hasFP(MF) && AFI->hasStackFrame()) {
|
|
|
|
// Use frame pointer to reference fixed objects. Use it for locals if
|
|
|
|
// there are VLAs (and thus the SP isn't reliable as a base).
|
2009-11-22 02:32:29 +00:00
|
|
|
if (isFixed || MFI->hasVarSizedObjects()) {
|
|
|
|
FrameReg = getFrameRegister(MF);
|
2010-08-05 19:27:37 +00:00
|
|
|
Offset = FPOffset;
|
2009-11-22 02:32:29 +00:00
|
|
|
} else if (AFI->isThumb2Function()) {
|
2010-08-05 19:27:37 +00:00
|
|
|
// In Thumb2 mode, the negative offset is very limited. Try to avoid
|
|
|
|
// out of range references.
|
2009-11-22 02:32:29 +00:00
|
|
|
if (FPOffset >= -255 && FPOffset < 0) {
|
|
|
|
FrameReg = getFrameRegister(MF);
|
|
|
|
Offset = FPOffset;
|
|
|
|
}
|
2010-08-05 19:27:37 +00:00
|
|
|
} else if (Offset > (FPOffset < 0 ? -FPOffset : FPOffset)) {
|
|
|
|
// Otherwise, use SP or FP, whichever is closer to the stack slot.
|
|
|
|
FrameReg = getFrameRegister(MF);
|
|
|
|
Offset = FPOffset;
|
2009-11-22 02:32:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return Offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2010-01-26 23:15:09 +00:00
|
|
|
ARMBaseRegisterInfo::getFrameIndexOffset(const MachineFunction &MF,
|
|
|
|
int FI) const {
|
2009-11-22 02:32:29 +00:00
|
|
|
unsigned FrameReg;
|
|
|
|
return getFrameIndexReference(MF, FI, FrameReg);
|
|
|
|
}
|
|
|
|
|
2009-07-08 17:28:55 +00:00
|
|
|
unsigned ARMBaseRegisterInfo::getEHExceptionRegister() const {
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("What is the exception register");
|
2009-07-08 17:28:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned ARMBaseRegisterInfo::getEHHandlerRegister() const {
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("What is the exception handler register");
|
2009-07-08 17:28:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ARMBaseRegisterInfo::getDwarfRegNum(unsigned RegNum, bool isEH) const {
|
|
|
|
return ARMGenRegisterInfo::getDwarfRegNumFull(RegNum, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned ARMBaseRegisterInfo::getRegisterPairEven(unsigned Reg,
|
2010-01-06 23:54:42 +00:00
|
|
|
const MachineFunction &MF) const {
|
2009-07-08 17:28:55 +00:00
|
|
|
switch (Reg) {
|
|
|
|
default: break;
|
|
|
|
// Return 0 if either register of the pair is a special register.
|
|
|
|
// So no R12, etc.
|
|
|
|
case ARM::R1:
|
|
|
|
return ARM::R0;
|
|
|
|
case ARM::R3:
|
2009-10-19 22:57:03 +00:00
|
|
|
return ARM::R2;
|
2009-07-08 17:28:55 +00:00
|
|
|
case ARM::R5:
|
|
|
|
return ARM::R4;
|
|
|
|
case ARM::R7:
|
|
|
|
return isReservedReg(MF, ARM::R7) ? 0 : ARM::R6;
|
|
|
|
case ARM::R9:
|
|
|
|
return isReservedReg(MF, ARM::R9) ? 0 :ARM::R8;
|
|
|
|
case ARM::R11:
|
|
|
|
return isReservedReg(MF, ARM::R11) ? 0 : ARM::R10;
|
|
|
|
|
|
|
|
case ARM::S1:
|
|
|
|
return ARM::S0;
|
|
|
|
case ARM::S3:
|
|
|
|
return ARM::S2;
|
|
|
|
case ARM::S5:
|
|
|
|
return ARM::S4;
|
|
|
|
case ARM::S7:
|
|
|
|
return ARM::S6;
|
|
|
|
case ARM::S9:
|
|
|
|
return ARM::S8;
|
|
|
|
case ARM::S11:
|
|
|
|
return ARM::S10;
|
|
|
|
case ARM::S13:
|
|
|
|
return ARM::S12;
|
|
|
|
case ARM::S15:
|
|
|
|
return ARM::S14;
|
|
|
|
case ARM::S17:
|
|
|
|
return ARM::S16;
|
|
|
|
case ARM::S19:
|
|
|
|
return ARM::S18;
|
|
|
|
case ARM::S21:
|
|
|
|
return ARM::S20;
|
|
|
|
case ARM::S23:
|
|
|
|
return ARM::S22;
|
|
|
|
case ARM::S25:
|
|
|
|
return ARM::S24;
|
|
|
|
case ARM::S27:
|
|
|
|
return ARM::S26;
|
|
|
|
case ARM::S29:
|
|
|
|
return ARM::S28;
|
|
|
|
case ARM::S31:
|
|
|
|
return ARM::S30;
|
|
|
|
|
|
|
|
case ARM::D1:
|
|
|
|
return ARM::D0;
|
|
|
|
case ARM::D3:
|
|
|
|
return ARM::D2;
|
|
|
|
case ARM::D5:
|
|
|
|
return ARM::D4;
|
|
|
|
case ARM::D7:
|
|
|
|
return ARM::D6;
|
|
|
|
case ARM::D9:
|
|
|
|
return ARM::D8;
|
|
|
|
case ARM::D11:
|
|
|
|
return ARM::D10;
|
|
|
|
case ARM::D13:
|
|
|
|
return ARM::D12;
|
|
|
|
case ARM::D15:
|
|
|
|
return ARM::D14;
|
2009-07-22 05:55:18 +00:00
|
|
|
case ARM::D17:
|
|
|
|
return ARM::D16;
|
|
|
|
case ARM::D19:
|
|
|
|
return ARM::D18;
|
|
|
|
case ARM::D21:
|
|
|
|
return ARM::D20;
|
|
|
|
case ARM::D23:
|
|
|
|
return ARM::D22;
|
|
|
|
case ARM::D25:
|
|
|
|
return ARM::D24;
|
|
|
|
case ARM::D27:
|
|
|
|
return ARM::D26;
|
|
|
|
case ARM::D29:
|
|
|
|
return ARM::D28;
|
|
|
|
case ARM::D31:
|
|
|
|
return ARM::D30;
|
2009-07-08 17:28:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned ARMBaseRegisterInfo::getRegisterPairOdd(unsigned Reg,
|
|
|
|
const MachineFunction &MF) const {
|
|
|
|
switch (Reg) {
|
|
|
|
default: break;
|
|
|
|
// Return 0 if either register of the pair is a special register.
|
|
|
|
// So no R12, etc.
|
|
|
|
case ARM::R0:
|
|
|
|
return ARM::R1;
|
|
|
|
case ARM::R2:
|
2009-10-19 22:57:03 +00:00
|
|
|
return ARM::R3;
|
2009-07-08 17:28:55 +00:00
|
|
|
case ARM::R4:
|
|
|
|
return ARM::R5;
|
|
|
|
case ARM::R6:
|
|
|
|
return isReservedReg(MF, ARM::R7) ? 0 : ARM::R7;
|
|
|
|
case ARM::R8:
|
|
|
|
return isReservedReg(MF, ARM::R9) ? 0 :ARM::R9;
|
|
|
|
case ARM::R10:
|
|
|
|
return isReservedReg(MF, ARM::R11) ? 0 : ARM::R11;
|
|
|
|
|
|
|
|
case ARM::S0:
|
|
|
|
return ARM::S1;
|
|
|
|
case ARM::S2:
|
|
|
|
return ARM::S3;
|
|
|
|
case ARM::S4:
|
|
|
|
return ARM::S5;
|
|
|
|
case ARM::S6:
|
|
|
|
return ARM::S7;
|
|
|
|
case ARM::S8:
|
|
|
|
return ARM::S9;
|
|
|
|
case ARM::S10:
|
|
|
|
return ARM::S11;
|
|
|
|
case ARM::S12:
|
|
|
|
return ARM::S13;
|
|
|
|
case ARM::S14:
|
|
|
|
return ARM::S15;
|
|
|
|
case ARM::S16:
|
|
|
|
return ARM::S17;
|
|
|
|
case ARM::S18:
|
|
|
|
return ARM::S19;
|
|
|
|
case ARM::S20:
|
|
|
|
return ARM::S21;
|
|
|
|
case ARM::S22:
|
|
|
|
return ARM::S23;
|
|
|
|
case ARM::S24:
|
|
|
|
return ARM::S25;
|
|
|
|
case ARM::S26:
|
|
|
|
return ARM::S27;
|
|
|
|
case ARM::S28:
|
|
|
|
return ARM::S29;
|
|
|
|
case ARM::S30:
|
|
|
|
return ARM::S31;
|
|
|
|
|
|
|
|
case ARM::D0:
|
|
|
|
return ARM::D1;
|
|
|
|
case ARM::D2:
|
|
|
|
return ARM::D3;
|
|
|
|
case ARM::D4:
|
|
|
|
return ARM::D5;
|
|
|
|
case ARM::D6:
|
|
|
|
return ARM::D7;
|
|
|
|
case ARM::D8:
|
|
|
|
return ARM::D9;
|
|
|
|
case ARM::D10:
|
|
|
|
return ARM::D11;
|
|
|
|
case ARM::D12:
|
|
|
|
return ARM::D13;
|
|
|
|
case ARM::D14:
|
|
|
|
return ARM::D15;
|
2009-07-22 05:55:18 +00:00
|
|
|
case ARM::D16:
|
|
|
|
return ARM::D17;
|
|
|
|
case ARM::D18:
|
|
|
|
return ARM::D19;
|
|
|
|
case ARM::D20:
|
|
|
|
return ARM::D21;
|
|
|
|
case ARM::D22:
|
|
|
|
return ARM::D23;
|
|
|
|
case ARM::D24:
|
|
|
|
return ARM::D25;
|
|
|
|
case ARM::D26:
|
|
|
|
return ARM::D27;
|
|
|
|
case ARM::D28:
|
|
|
|
return ARM::D29;
|
|
|
|
case ARM::D30:
|
|
|
|
return ARM::D31;
|
2009-07-08 17:28:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-08 18:31:39 +00:00
|
|
|
/// emitLoadConstPool - Emits a load from constpool to materialize the
|
|
|
|
/// specified immediate.
|
|
|
|
void ARMBaseRegisterInfo::
|
|
|
|
emitLoadConstPool(MachineBasicBlock &MBB,
|
|
|
|
MachineBasicBlock::iterator &MBBI,
|
2009-07-08 20:28:28 +00:00
|
|
|
DebugLoc dl,
|
2009-07-16 09:20:10 +00:00
|
|
|
unsigned DestReg, unsigned SubIdx, int Val,
|
2009-07-08 18:31:39 +00:00
|
|
|
ARMCC::CondCodes Pred,
|
|
|
|
unsigned PredReg) const {
|
|
|
|
MachineFunction &MF = *MBB.getParent();
|
|
|
|
MachineConstantPool *ConstantPool = MF.getConstantPool();
|
2010-04-15 01:51:59 +00:00
|
|
|
const Constant *C =
|
2009-08-13 21:58:54 +00:00
|
|
|
ConstantInt::get(Type::getInt32Ty(MF.getFunction()->getContext()), Val);
|
2009-07-08 18:31:39 +00:00
|
|
|
unsigned Idx = ConstantPool->getConstantPoolIndex(C, 4);
|
|
|
|
|
2009-07-16 09:20:10 +00:00
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(ARM::LDRcp))
|
|
|
|
.addReg(DestReg, getDefRegState(true), SubIdx)
|
2009-07-08 18:31:39 +00:00
|
|
|
.addConstantPoolIndex(Idx)
|
|
|
|
.addReg(0).addImm(0).addImm(Pred).addReg(PredReg);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ARMBaseRegisterInfo::
|
|
|
|
requiresRegisterScavenging(const MachineFunction &MF) const {
|
|
|
|
return true;
|
|
|
|
}
|
2009-10-21 23:40:56 +00:00
|
|
|
|
2009-10-20 01:26:58 +00:00
|
|
|
bool ARMBaseRegisterInfo::
|
|
|
|
requiresFrameIndexScavenging(const MachineFunction &MF) const {
|
2009-10-28 17:33:28 +00:00
|
|
|
return true;
|
2009-10-20 01:26:58 +00:00
|
|
|
}
|
2009-07-08 18:31:39 +00:00
|
|
|
|
2010-08-24 19:05:43 +00:00
|
|
|
bool ARMBaseRegisterInfo::
|
|
|
|
requiresVirtualBaseRegisters(const MachineFunction &MF) const {
|
|
|
|
return EnableLocalStackAlloc;
|
|
|
|
}
|
|
|
|
|
2009-07-08 18:31:39 +00:00
|
|
|
// hasReservedCallFrame - Under normal circumstances, when a frame pointer is
|
|
|
|
// not required, we reserve argument space for call sites in the function
|
|
|
|
// immediately on entry to the current function. This eliminates the need for
|
|
|
|
// add/sub sp brackets around call sites. Returns true if the call frame is
|
|
|
|
// included as part of the stack frame.
|
|
|
|
bool ARMBaseRegisterInfo::
|
2010-07-20 06:52:21 +00:00
|
|
|
hasReservedCallFrame(const MachineFunction &MF) const {
|
2009-07-08 18:31:39 +00:00
|
|
|
const MachineFrameInfo *FFI = MF.getFrameInfo();
|
|
|
|
unsigned CFSize = FFI->getMaxCallFrameSize();
|
|
|
|
// It's not always a good idea to include the call frame as part of the
|
|
|
|
// stack frame. ARM (especially Thumb) has small immediate offset to
|
|
|
|
// address the stack frame. So a large call frame can cause poor codegen
|
|
|
|
// and may even makes it impossible to scavenge a register.
|
|
|
|
if (CFSize >= ((1 << 12) - 1) / 2) // Half of imm12
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return !MF.getFrameInfo()->hasVarSizedObjects();
|
|
|
|
}
|
|
|
|
|
2010-02-22 23:10:38 +00:00
|
|
|
// canSimplifyCallFramePseudos - If there is a reserved call frame, the
|
|
|
|
// call frame pseudos can be simplified. Unlike most targets, having a FP
|
|
|
|
// is not sufficient here since we still may reference some objects via SP
|
|
|
|
// even when FP is available in Thumb2 mode.
|
|
|
|
bool ARMBaseRegisterInfo::
|
2010-07-20 06:52:21 +00:00
|
|
|
canSimplifyCallFramePseudos(const MachineFunction &MF) const {
|
2010-02-24 02:15:43 +00:00
|
|
|
return hasReservedCallFrame(MF) || MF.getFrameInfo()->hasVarSizedObjects();
|
2010-02-22 23:10:38 +00:00
|
|
|
}
|
|
|
|
|
2009-07-08 18:31:39 +00:00
|
|
|
static void
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(bool isARM,
|
|
|
|
MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
|
|
|
|
DebugLoc dl, const ARMBaseInstrInfo &TII,
|
2009-07-08 18:31:39 +00:00
|
|
|
int NumBytes,
|
|
|
|
ARMCC::CondCodes Pred = ARMCC::AL, unsigned PredReg = 0) {
|
2009-07-28 05:48:47 +00:00
|
|
|
if (isARM)
|
|
|
|
emitARMRegPlusImmediate(MBB, MBBI, dl, ARM::SP, ARM::SP, NumBytes,
|
|
|
|
Pred, PredReg, TII);
|
|
|
|
else
|
|
|
|
emitT2RegPlusImmediate(MBB, MBBI, dl, ARM::SP, ARM::SP, NumBytes,
|
|
|
|
Pred, PredReg, TII);
|
2009-07-08 18:31:39 +00:00
|
|
|
}
|
|
|
|
|
2009-07-28 05:48:47 +00:00
|
|
|
|
2009-07-08 18:31:39 +00:00
|
|
|
void ARMBaseRegisterInfo::
|
|
|
|
eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
|
|
|
|
MachineBasicBlock::iterator I) const {
|
|
|
|
if (!hasReservedCallFrame(MF)) {
|
|
|
|
// If we have alloca, convert as follows:
|
|
|
|
// ADJCALLSTACKDOWN -> sub, sp, sp, amount
|
|
|
|
// ADJCALLSTACKUP -> add, sp, sp, amount
|
|
|
|
MachineInstr *Old = I;
|
|
|
|
DebugLoc dl = Old->getDebugLoc();
|
|
|
|
unsigned Amount = Old->getOperand(0).getImm();
|
|
|
|
if (Amount != 0) {
|
|
|
|
// We need to keep the stack aligned properly. To do this, we round the
|
|
|
|
// amount of space needed for the outgoing arguments up to the next
|
|
|
|
// alignment boundary.
|
|
|
|
unsigned Align = MF.getTarget().getFrameInfo()->getStackAlignment();
|
|
|
|
Amount = (Amount+Align-1)/Align*Align;
|
|
|
|
|
2009-07-28 05:48:47 +00:00
|
|
|
ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
|
|
|
|
assert(!AFI->isThumb1OnlyFunction() &&
|
2010-02-23 17:16:27 +00:00
|
|
|
"This eliminateCallFramePseudoInstr does not support Thumb1!");
|
2009-07-28 05:48:47 +00:00
|
|
|
bool isARM = !AFI->isThumbFunction();
|
|
|
|
|
2009-07-08 18:31:39 +00:00
|
|
|
// Replace the pseudo instruction with a new instruction...
|
|
|
|
unsigned Opc = Old->getOpcode();
|
2010-02-22 22:47:46 +00:00
|
|
|
int PIdx = Old->findFirstPredOperandIdx();
|
|
|
|
ARMCC::CondCodes Pred = (PIdx == -1)
|
|
|
|
? ARMCC::AL : (ARMCC::CondCodes)Old->getOperand(PIdx).getImm();
|
2009-07-08 18:31:39 +00:00
|
|
|
if (Opc == ARM::ADJCALLSTACKDOWN || Opc == ARM::tADJCALLSTACKDOWN) {
|
|
|
|
// Note: PredReg is operand 2 for ADJCALLSTACKDOWN.
|
|
|
|
unsigned PredReg = Old->getOperand(2).getReg();
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, I, dl, TII, -Amount, Pred, PredReg);
|
2009-07-08 18:31:39 +00:00
|
|
|
} else {
|
|
|
|
// Note: PredReg is operand 3 for ADJCALLSTACKUP.
|
|
|
|
unsigned PredReg = Old->getOperand(3).getReg();
|
|
|
|
assert(Opc == ARM::ADJCALLSTACKUP || Opc == ARM::tADJCALLSTACKUP);
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, I, dl, TII, Amount, Pred, PredReg);
|
2009-07-08 18:31:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
MBB.erase(I);
|
|
|
|
}
|
|
|
|
|
2010-08-19 23:52:25 +00:00
|
|
|
int64_t ARMBaseRegisterInfo::
|
2010-08-26 21:56:30 +00:00
|
|
|
getFrameIndexInstrOffset(const MachineInstr *MI, int Idx) const {
|
2010-08-19 23:52:25 +00:00
|
|
|
const TargetInstrDesc &Desc = MI->getDesc();
|
|
|
|
unsigned AddrMode = (Desc.TSFlags & ARMII::AddrModeMask);
|
|
|
|
int64_t InstrOffs = 0;;
|
|
|
|
int Scale = 1;
|
|
|
|
unsigned ImmIdx = 0;
|
2010-08-26 21:56:30 +00:00
|
|
|
switch (AddrMode) {
|
2010-08-19 23:52:25 +00:00
|
|
|
case ARMII::AddrModeT2_i8:
|
|
|
|
case ARMII::AddrModeT2_i12:
|
|
|
|
// i8 supports only negative, and i12 supports only positive, so
|
|
|
|
// based on Offset sign, consider the appropriate instruction
|
|
|
|
InstrOffs = MI->getOperand(Idx+1).getImm();
|
|
|
|
Scale = 1;
|
|
|
|
break;
|
|
|
|
case ARMII::AddrMode5: {
|
|
|
|
// VFP address mode.
|
|
|
|
const MachineOperand &OffOp = MI->getOperand(Idx+1);
|
2010-08-25 19:11:34 +00:00
|
|
|
InstrOffs = ARM_AM::getAM5Offset(OffOp.getImm());
|
2010-08-19 23:52:25 +00:00
|
|
|
if (ARM_AM::getAM5Op(OffOp.getImm()) == ARM_AM::sub)
|
|
|
|
InstrOffs = -InstrOffs;
|
|
|
|
Scale = 4;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ARMII::AddrMode2: {
|
|
|
|
ImmIdx = Idx+2;
|
|
|
|
InstrOffs = ARM_AM::getAM2Offset(MI->getOperand(ImmIdx).getImm());
|
|
|
|
if (ARM_AM::getAM2Op(MI->getOperand(ImmIdx).getImm()) == ARM_AM::sub)
|
|
|
|
InstrOffs = -InstrOffs;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ARMII::AddrMode3: {
|
|
|
|
ImmIdx = Idx+2;
|
|
|
|
InstrOffs = ARM_AM::getAM3Offset(MI->getOperand(ImmIdx).getImm());
|
|
|
|
if (ARM_AM::getAM3Op(MI->getOperand(ImmIdx).getImm()) == ARM_AM::sub)
|
|
|
|
InstrOffs = -InstrOffs;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ARMII::AddrModeT1_s: {
|
|
|
|
ImmIdx = Idx+1;
|
|
|
|
InstrOffs = MI->getOperand(ImmIdx).getImm();
|
|
|
|
Scale = 4;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Unsupported addressing mode!");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return InstrOffs * Scale;
|
|
|
|
}
|
|
|
|
|
2010-08-17 18:13:53 +00:00
|
|
|
/// needsFrameBaseReg - Returns true if the instruction's frame index
|
|
|
|
/// reference would be better served by a base register other than FP
|
|
|
|
/// or SP. Used by LocalStackFrameAllocation to determine which frame index
|
|
|
|
/// references it should create new base registers for.
|
|
|
|
bool ARMBaseRegisterInfo::
|
2010-08-24 21:19:33 +00:00
|
|
|
needsFrameBaseReg(MachineInstr *MI, int64_t Offset) const {
|
|
|
|
for (unsigned i = 0; !MI->getOperand(i).isFI(); ++i) {
|
|
|
|
assert(i < MI->getNumOperands() &&"Instr doesn't have FrameIndex operand!");
|
|
|
|
}
|
2010-08-17 18:13:53 +00:00
|
|
|
|
|
|
|
// It's the load/store FI references that cause issues, as it can be difficult
|
|
|
|
// to materialize the offset if it won't fit in the literal field. Estimate
|
|
|
|
// based on the size of the local frame and some conservative assumptions
|
|
|
|
// about the rest of the stack frame (note, this is pre-regalloc, so
|
|
|
|
// we don't know everything for certain yet) whether this offset is likely
|
|
|
|
// to be out of range of the immediate. Return true if so.
|
|
|
|
|
2010-08-24 18:04:52 +00:00
|
|
|
// We only generate virtual base registers for loads and stores, so
|
|
|
|
// return false for everything else.
|
2010-08-17 18:13:53 +00:00
|
|
|
unsigned Opc = MI->getOpcode();
|
|
|
|
switch (Opc) {
|
|
|
|
case ARM::LDR: case ARM::LDRH: case ARM::LDRB:
|
|
|
|
case ARM::STR: case ARM::STRH: case ARM::STRB:
|
|
|
|
case ARM::t2LDRi12: case ARM::t2LDRi8:
|
|
|
|
case ARM::t2STRi12: case ARM::t2STRi8:
|
|
|
|
case ARM::VLDRS: case ARM::VLDRD:
|
|
|
|
case ARM::VSTRS: case ARM::VSTRD:
|
2010-08-19 17:52:13 +00:00
|
|
|
case ARM::tSTRspi: case ARM::tLDRspi:
|
2010-08-24 18:04:52 +00:00
|
|
|
if (ForceAllBaseRegAlloc)
|
|
|
|
return true;
|
|
|
|
break;
|
2010-08-17 18:13:53 +00:00
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
2010-08-24 18:04:52 +00:00
|
|
|
|
|
|
|
// Without a virtual base register, if the function has variable sized
|
|
|
|
// objects, all fixed-size local references will be via the frame pointer,
|
2010-08-24 21:19:33 +00:00
|
|
|
// Approximate the offset and see if it's legal for the instruction.
|
|
|
|
// Note that the incoming offset is based on the SP value at function entry,
|
|
|
|
// so it'll be negative.
|
|
|
|
MachineFunction &MF = *MI->getParent()->getParent();
|
|
|
|
MachineFrameInfo *MFI = MF.getFrameInfo();
|
|
|
|
ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
|
|
|
|
|
|
|
|
// Estimate an offset from the frame pointer.
|
|
|
|
// Conservatively assume all callee-saved registers get pushed. R4-R6
|
|
|
|
// will be earlier than the FP, so we ignore those.
|
|
|
|
// R7, LR
|
|
|
|
int64_t FPOffset = Offset - 8;
|
|
|
|
// ARM and Thumb2 functions also need to consider R8-R11 and D8-D15
|
|
|
|
if (!AFI->isThumbFunction() || !AFI->isThumb1OnlyFunction())
|
|
|
|
FPOffset -= 80;
|
|
|
|
// Estimate an offset from the stack pointer.
|
2010-08-31 18:52:31 +00:00
|
|
|
// The incoming offset is relating to the SP at the start of the function,
|
|
|
|
// but when we access the local it'll be relative to the SP after local
|
|
|
|
// allocation, so adjust our SP-relative offset by that allocation size.
|
2010-08-24 21:19:33 +00:00
|
|
|
Offset = -Offset;
|
2010-08-31 18:52:31 +00:00
|
|
|
Offset += MFI->getLocalFrameSize();
|
2010-08-24 21:19:33 +00:00
|
|
|
// Assume that we'll have at least some spill slots allocated.
|
|
|
|
// FIXME: This is a total SWAG number. We should run some statistics
|
|
|
|
// and pick a real one.
|
|
|
|
Offset += 128; // 128 bytes of spill slots
|
|
|
|
|
|
|
|
// If there is a frame pointer, try using it.
|
|
|
|
// The FP is only available if there is no dynamic realignment. We
|
|
|
|
// don't know for sure yet whether we'll need that, so we guess based
|
|
|
|
// on whether there are any local variables that would trigger it.
|
|
|
|
unsigned StackAlign = MF.getTarget().getFrameInfo()->getStackAlignment();
|
|
|
|
if (hasFP(MF) &&
|
|
|
|
!((MFI->getLocalFrameMaxAlign() > StackAlign) && canRealignStack(MF))) {
|
|
|
|
if (isFrameOffsetLegal(MI, FPOffset))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// If we can reference via the stack pointer, try that.
|
|
|
|
// FIXME: This (and the code that resolves the references) can be improved
|
|
|
|
// to only disallow SP relative references in the live range of
|
|
|
|
// the VLA(s). In practice, it's unclear how much difference that
|
|
|
|
// would make, but it may be worth doing.
|
|
|
|
if (!MFI->hasVarSizedObjects() && isFrameOffsetLegal(MI, Offset))
|
|
|
|
return false;
|
2010-08-24 18:04:52 +00:00
|
|
|
|
2010-08-24 21:19:33 +00:00
|
|
|
// The offset likely isn't legal, we want to allocate a virtual base register.
|
2010-08-24 18:04:52 +00:00
|
|
|
return true;
|
2010-08-17 18:13:53 +00:00
|
|
|
}
|
|
|
|
|
2010-08-17 22:41:55 +00:00
|
|
|
/// materializeFrameBaseRegister - Insert defining instruction(s) for
|
|
|
|
/// BaseReg to be a pointer to FrameIdx before insertion point I.
|
|
|
|
void ARMBaseRegisterInfo::
|
2010-08-19 23:52:25 +00:00
|
|
|
materializeFrameBaseRegister(MachineBasicBlock::iterator I, unsigned BaseReg,
|
|
|
|
int FrameIdx, int64_t Offset) const {
|
2010-08-17 22:41:55 +00:00
|
|
|
ARMFunctionInfo *AFI =
|
|
|
|
I->getParent()->getParent()->getInfo<ARMFunctionInfo>();
|
2010-08-19 17:52:13 +00:00
|
|
|
unsigned ADDriOpc = !AFI->isThumbFunction() ? ARM::ADDri :
|
|
|
|
(AFI->isThumb1OnlyFunction() ? ARM::tADDrSPi : ARM::t2ADDri);
|
2010-08-17 22:41:55 +00:00
|
|
|
|
|
|
|
MachineInstrBuilder MIB =
|
|
|
|
BuildMI(*I->getParent(), I, I->getDebugLoc(), TII.get(ADDriOpc), BaseReg)
|
2010-08-19 23:52:25 +00:00
|
|
|
.addFrameIndex(FrameIdx).addImm(Offset);
|
2010-08-19 17:52:13 +00:00
|
|
|
if (!AFI->isThumb1OnlyFunction())
|
|
|
|
AddDefaultCC(AddDefaultPred(MIB));
|
2010-08-17 22:41:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ARMBaseRegisterInfo::resolveFrameIndex(MachineBasicBlock::iterator I,
|
|
|
|
unsigned BaseReg, int64_t Offset) const {
|
|
|
|
MachineInstr &MI = *I;
|
|
|
|
MachineBasicBlock &MBB = *MI.getParent();
|
|
|
|
MachineFunction &MF = *MBB.getParent();
|
|
|
|
ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
|
|
|
|
int Off = Offset; // ARM doesn't need the general 64-bit offsets
|
|
|
|
unsigned i = 0;
|
|
|
|
|
|
|
|
assert(!AFI->isThumb1OnlyFunction() &&
|
|
|
|
"This resolveFrameIndex does not support Thumb1!");
|
|
|
|
|
|
|
|
while (!MI.getOperand(i).isFI()) {
|
|
|
|
++i;
|
|
|
|
assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!");
|
|
|
|
}
|
|
|
|
bool Done = false;
|
|
|
|
if (!AFI->isThumbFunction())
|
|
|
|
Done = rewriteARMFrameIndex(MI, i, BaseReg, Off, TII);
|
|
|
|
else {
|
|
|
|
assert(AFI->isThumb2Function());
|
|
|
|
Done = rewriteT2FrameIndex(MI, i, BaseReg, Off, TII);
|
|
|
|
}
|
|
|
|
assert (Done && "Unable to resolve frame index!");
|
|
|
|
}
|
2010-08-17 18:13:53 +00:00
|
|
|
|
2010-08-19 23:52:25 +00:00
|
|
|
bool ARMBaseRegisterInfo::isFrameOffsetLegal(const MachineInstr *MI,
|
|
|
|
int64_t Offset) const {
|
2010-08-18 22:44:49 +00:00
|
|
|
const TargetInstrDesc &Desc = MI->getDesc();
|
|
|
|
unsigned AddrMode = (Desc.TSFlags & ARMII::AddrModeMask);
|
|
|
|
unsigned i = 0;
|
|
|
|
|
|
|
|
while (!MI->getOperand(i).isFI()) {
|
|
|
|
++i;
|
|
|
|
assert(i < MI->getNumOperands() &&"Instr doesn't have FrameIndex operand!");
|
|
|
|
}
|
|
|
|
|
|
|
|
// AddrMode4 and AddrMode6 cannot handle any offset.
|
|
|
|
if (AddrMode == ARMII::AddrMode4 || AddrMode == ARMII::AddrMode6)
|
|
|
|
return Offset == 0;
|
|
|
|
|
|
|
|
unsigned NumBits = 0;
|
|
|
|
unsigned Scale = 1;
|
2010-08-19 23:52:25 +00:00
|
|
|
bool isSigned = true;
|
2010-08-26 21:56:30 +00:00
|
|
|
switch (AddrMode) {
|
2010-08-18 22:44:49 +00:00
|
|
|
case ARMII::AddrModeT2_i8:
|
|
|
|
case ARMII::AddrModeT2_i12:
|
|
|
|
// i8 supports only negative, and i12 supports only positive, so
|
|
|
|
// based on Offset sign, consider the appropriate instruction
|
2010-08-19 17:52:13 +00:00
|
|
|
Scale = 1;
|
2010-08-18 22:44:49 +00:00
|
|
|
if (Offset < 0) {
|
|
|
|
NumBits = 8;
|
|
|
|
Offset = -Offset;
|
|
|
|
} else {
|
|
|
|
NumBits = 12;
|
|
|
|
}
|
|
|
|
break;
|
2010-08-26 21:56:30 +00:00
|
|
|
case ARMII::AddrMode5:
|
2010-08-18 22:44:49 +00:00
|
|
|
// VFP address mode.
|
|
|
|
NumBits = 8;
|
|
|
|
Scale = 4;
|
|
|
|
break;
|
2010-08-26 21:56:30 +00:00
|
|
|
case ARMII::AddrMode2:
|
2010-08-18 22:44:49 +00:00
|
|
|
NumBits = 12;
|
|
|
|
break;
|
2010-08-26 21:56:30 +00:00
|
|
|
case ARMII::AddrMode3:
|
2010-08-18 22:44:49 +00:00
|
|
|
NumBits = 8;
|
|
|
|
break;
|
2010-08-26 21:56:30 +00:00
|
|
|
case ARMII::AddrModeT1_s:
|
2010-08-19 17:52:13 +00:00
|
|
|
NumBits = 5;
|
|
|
|
Scale = 4;
|
2010-08-19 23:52:25 +00:00
|
|
|
isSigned = false;
|
2010-08-19 17:52:13 +00:00
|
|
|
break;
|
2010-08-18 22:44:49 +00:00
|
|
|
default:
|
|
|
|
llvm_unreachable("Unsupported addressing mode!");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-08-26 21:56:30 +00:00
|
|
|
Offset += getFrameIndexInstrOffset(MI, i);
|
2010-08-31 18:49:31 +00:00
|
|
|
// Make sure the offset is encodable for instructions that scale the
|
|
|
|
// immediate.
|
|
|
|
if ((Offset & (Scale-1)) != 0)
|
|
|
|
return false;
|
|
|
|
|
2010-08-19 23:52:25 +00:00
|
|
|
if (isSigned && Offset < 0)
|
2010-08-18 22:44:49 +00:00
|
|
|
Offset = -Offset;
|
|
|
|
|
|
|
|
unsigned Mask = (1 << NumBits) - 1;
|
|
|
|
if ((unsigned)Offset <= Mask * Scale)
|
|
|
|
return true;
|
2010-08-18 17:57:37 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-08-26 23:32:16 +00:00
|
|
|
void
|
2009-07-28 05:48:47 +00:00
|
|
|
ARMBaseRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
|
2010-08-26 23:32:16 +00:00
|
|
|
int SPAdj, RegScavenger *RS) const {
|
2009-07-24 00:16:18 +00:00
|
|
|
unsigned i = 0;
|
|
|
|
MachineInstr &MI = *II;
|
|
|
|
MachineBasicBlock &MBB = *MI.getParent();
|
|
|
|
MachineFunction &MF = *MBB.getParent();
|
|
|
|
ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
|
2009-07-28 05:48:47 +00:00
|
|
|
assert(!AFI->isThumb1OnlyFunction() &&
|
2009-09-18 21:42:44 +00:00
|
|
|
"This eliminateFrameIndex does not support Thumb1!");
|
2009-07-24 00:16:18 +00:00
|
|
|
|
|
|
|
while (!MI.getOperand(i).isFI()) {
|
|
|
|
++i;
|
|
|
|
assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!");
|
|
|
|
}
|
|
|
|
|
|
|
|
int FrameIndex = MI.getOperand(i).getIndex();
|
2009-11-22 20:05:32 +00:00
|
|
|
unsigned FrameReg;
|
2009-07-24 00:16:18 +00:00
|
|
|
|
2010-08-05 19:27:37 +00:00
|
|
|
int Offset = ResolveFrameIndexReference(MF, FrameIndex, FrameReg, SPAdj);
|
2009-07-24 00:16:18 +00:00
|
|
|
|
2010-04-26 07:39:25 +00:00
|
|
|
// Special handling of dbg_value instructions.
|
|
|
|
if (MI.isDebugValue()) {
|
|
|
|
MI.getOperand(i). ChangeToRegister(FrameReg, false /*isDef*/);
|
|
|
|
MI.getOperand(i+1).ChangeToImmediate(Offset);
|
2010-08-26 23:32:16 +00:00
|
|
|
return;
|
2010-04-26 07:39:25 +00:00
|
|
|
}
|
|
|
|
|
2009-11-01 21:12:51 +00:00
|
|
|
// Modify MI as necessary to handle as much of 'Offset' as possible
|
2009-08-27 01:23:50 +00:00
|
|
|
bool Done = false;
|
2009-07-28 05:48:47 +00:00
|
|
|
if (!AFI->isThumbFunction())
|
2009-08-27 01:23:50 +00:00
|
|
|
Done = rewriteARMFrameIndex(MI, i, FrameReg, Offset, TII);
|
2009-07-28 05:48:47 +00:00
|
|
|
else {
|
|
|
|
assert(AFI->isThumb2Function());
|
2009-08-27 01:23:50 +00:00
|
|
|
Done = rewriteT2FrameIndex(MI, i, FrameReg, Offset, TII);
|
2009-07-28 05:48:47 +00:00
|
|
|
}
|
2009-08-27 01:23:50 +00:00
|
|
|
if (Done)
|
2010-08-26 23:32:16 +00:00
|
|
|
return;
|
2009-07-24 00:16:18 +00:00
|
|
|
|
2009-07-08 18:31:39 +00:00
|
|
|
// If we get here, the immediate doesn't fit into the instruction. We folded
|
|
|
|
// as much as possible above, handle the rest, providing a register that is
|
|
|
|
// SP+LargeImm.
|
2009-08-28 08:08:22 +00:00
|
|
|
assert((Offset ||
|
2009-11-15 21:45:34 +00:00
|
|
|
(MI.getDesc().TSFlags & ARMII::AddrModeMask) == ARMII::AddrMode4 ||
|
|
|
|
(MI.getDesc().TSFlags & ARMII::AddrModeMask) == ARMII::AddrMode6) &&
|
2009-08-27 01:23:50 +00:00
|
|
|
"This code isn't needed if offset already handled!");
|
2009-07-08 18:31:39 +00:00
|
|
|
|
2009-10-20 01:26:58 +00:00
|
|
|
unsigned ScratchReg = 0;
|
2009-07-08 18:31:39 +00:00
|
|
|
int PIdx = MI.findFirstPredOperandIdx();
|
|
|
|
ARMCC::CondCodes Pred = (PIdx == -1)
|
|
|
|
? ARMCC::AL : (ARMCC::CondCodes)MI.getOperand(PIdx).getImm();
|
|
|
|
unsigned PredReg = (PIdx == -1) ? 0 : MI.getOperand(PIdx+1).getReg();
|
2009-08-27 01:23:50 +00:00
|
|
|
if (Offset == 0)
|
2009-11-15 21:45:34 +00:00
|
|
|
// Must be addrmode4/6.
|
2009-08-27 01:23:50 +00:00
|
|
|
MI.getOperand(i).ChangeToRegister(FrameReg, false, false, false);
|
2009-07-28 05:48:47 +00:00
|
|
|
else {
|
2009-10-28 17:33:28 +00:00
|
|
|
ScratchReg = MF.getRegInfo().createVirtualRegister(ARM::GPRRegisterClass);
|
2009-08-27 01:23:50 +00:00
|
|
|
if (!AFI->isThumbFunction())
|
|
|
|
emitARMRegPlusImmediate(MBB, II, MI.getDebugLoc(), ScratchReg, FrameReg,
|
|
|
|
Offset, Pred, PredReg, TII);
|
|
|
|
else {
|
|
|
|
assert(AFI->isThumb2Function());
|
|
|
|
emitT2RegPlusImmediate(MBB, II, MI.getDebugLoc(), ScratchReg, FrameReg,
|
|
|
|
Offset, Pred, PredReg, TII);
|
|
|
|
}
|
|
|
|
MI.getOperand(i).ChangeToRegister(ScratchReg, false, false, true);
|
2009-07-28 05:48:47 +00:00
|
|
|
}
|
2009-07-08 18:31:39 +00:00
|
|
|
}
|
|
|
|
|
2009-11-04 23:20:40 +00:00
|
|
|
/// Move iterator past the next bunch of callee save load / store ops for
|
2009-07-08 18:31:39 +00:00
|
|
|
/// the particular spill area (1: integer area 1, 2: integer area 2,
|
|
|
|
/// 3: fp area, 0: don't care).
|
|
|
|
static void movePastCSLoadStoreOps(MachineBasicBlock &MBB,
|
|
|
|
MachineBasicBlock::iterator &MBBI,
|
2009-07-24 00:16:18 +00:00
|
|
|
int Opc1, int Opc2, unsigned Area,
|
2009-07-08 18:31:39 +00:00
|
|
|
const ARMSubtarget &STI) {
|
|
|
|
while (MBBI != MBB.end() &&
|
2009-07-24 00:16:18 +00:00
|
|
|
((MBBI->getOpcode() == Opc1) || (MBBI->getOpcode() == Opc2)) &&
|
|
|
|
MBBI->getOperand(1).isFI()) {
|
2009-07-08 18:31:39 +00:00
|
|
|
if (Area != 0) {
|
|
|
|
bool Done = false;
|
|
|
|
unsigned Category = 0;
|
|
|
|
switch (MBBI->getOperand(0).getReg()) {
|
|
|
|
case ARM::R4: case ARM::R5: case ARM::R6: case ARM::R7:
|
|
|
|
case ARM::LR:
|
|
|
|
Category = 1;
|
|
|
|
break;
|
|
|
|
case ARM::R8: case ARM::R9: case ARM::R10: case ARM::R11:
|
|
|
|
Category = STI.isTargetDarwin() ? 2 : 1;
|
|
|
|
break;
|
|
|
|
case ARM::D8: case ARM::D9: case ARM::D10: case ARM::D11:
|
|
|
|
case ARM::D12: case ARM::D13: case ARM::D14: case ARM::D15:
|
|
|
|
Category = 3;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
Done = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (Done || Category != Area)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
++MBBI;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ARMBaseRegisterInfo::
|
|
|
|
emitPrologue(MachineFunction &MF) const {
|
|
|
|
MachineBasicBlock &MBB = MF.front();
|
|
|
|
MachineBasicBlock::iterator MBBI = MBB.begin();
|
|
|
|
MachineFrameInfo *MFI = MF.getFrameInfo();
|
|
|
|
ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
|
2009-07-28 05:48:47 +00:00
|
|
|
assert(!AFI->isThumb1OnlyFunction() &&
|
2010-02-23 17:16:27 +00:00
|
|
|
"This emitPrologue does not support Thumb1!");
|
2009-07-28 05:48:47 +00:00
|
|
|
bool isARM = !AFI->isThumbFunction();
|
2009-07-08 18:31:39 +00:00
|
|
|
unsigned VARegSaveSize = AFI->getVarArgsRegSaveSize();
|
|
|
|
unsigned NumBytes = MFI->getStackSize();
|
|
|
|
const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
|
2010-04-02 20:16:16 +00:00
|
|
|
DebugLoc dl = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
|
2009-07-08 18:31:39 +00:00
|
|
|
|
|
|
|
// Determine the sizes of each callee-save spill areas and record which frame
|
|
|
|
// belongs to which callee-save spill areas.
|
|
|
|
unsigned GPRCS1Size = 0, GPRCS2Size = 0, DPRCSSize = 0;
|
|
|
|
int FramePtrSpillFI = 0;
|
|
|
|
|
2009-09-25 16:34:46 +00:00
|
|
|
// Allocate the vararg register save area. This is not counted in NumBytes.
|
2009-07-08 18:31:39 +00:00
|
|
|
if (VARegSaveSize)
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, -VARegSaveSize);
|
2009-07-08 18:31:39 +00:00
|
|
|
|
|
|
|
if (!AFI->hasStackFrame()) {
|
|
|
|
if (NumBytes != 0)
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, -NumBytes);
|
2009-07-08 18:31:39 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
|
|
|
|
unsigned Reg = CSI[i].getReg();
|
|
|
|
int FI = CSI[i].getFrameIdx();
|
|
|
|
switch (Reg) {
|
|
|
|
case ARM::R4:
|
|
|
|
case ARM::R5:
|
|
|
|
case ARM::R6:
|
|
|
|
case ARM::R7:
|
|
|
|
case ARM::LR:
|
|
|
|
if (Reg == FramePtr)
|
|
|
|
FramePtrSpillFI = FI;
|
|
|
|
AFI->addGPRCalleeSavedArea1Frame(FI);
|
|
|
|
GPRCS1Size += 4;
|
|
|
|
break;
|
|
|
|
case ARM::R8:
|
|
|
|
case ARM::R9:
|
|
|
|
case ARM::R10:
|
|
|
|
case ARM::R11:
|
|
|
|
if (Reg == FramePtr)
|
|
|
|
FramePtrSpillFI = FI;
|
|
|
|
if (STI.isTargetDarwin()) {
|
|
|
|
AFI->addGPRCalleeSavedArea2Frame(FI);
|
|
|
|
GPRCS2Size += 4;
|
|
|
|
} else {
|
|
|
|
AFI->addGPRCalleeSavedArea1Frame(FI);
|
|
|
|
GPRCS1Size += 4;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
AFI->addDPRCalleeSavedAreaFrame(FI);
|
|
|
|
DPRCSSize += 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Build the new SUBri to adjust SP for integer callee-save spill area 1.
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, -GPRCS1Size);
|
2009-07-27 03:14:20 +00:00
|
|
|
movePastCSLoadStoreOps(MBB, MBBI, ARM::STR, ARM::t2STRi12, 1, STI);
|
2009-07-08 18:31:39 +00:00
|
|
|
|
2009-09-25 16:34:46 +00:00
|
|
|
// Set FP to point to the stack slot that contains the previous FP.
|
|
|
|
// For Darwin, FP is R7, which has now been stored in spill area 1.
|
|
|
|
// Otherwise, if this is not Darwin, all the callee-saved registers go
|
|
|
|
// into spill area 1, including the FP in R11. In either case, it is
|
|
|
|
// now safe to emit this assignment.
|
2010-08-10 19:30:19 +00:00
|
|
|
bool HasFP = hasFP(MF);
|
|
|
|
if (HasFP) {
|
2009-07-28 05:48:47 +00:00
|
|
|
unsigned ADDriOpc = !AFI->isThumbFunction() ? ARM::ADDri : ARM::t2ADDri;
|
2009-07-08 18:31:39 +00:00
|
|
|
MachineInstrBuilder MIB =
|
2009-07-28 05:48:47 +00:00
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(ADDriOpc), FramePtr)
|
2009-07-08 18:31:39 +00:00
|
|
|
.addFrameIndex(FramePtrSpillFI).addImm(0);
|
|
|
|
AddDefaultCC(AddDefaultPred(MIB));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Build the new SUBri to adjust SP for integer callee-save spill area 2.
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, -GPRCS2Size);
|
2009-07-08 18:31:39 +00:00
|
|
|
|
|
|
|
// Build the new SUBri to adjust SP for FP callee-save spill area.
|
2009-07-27 03:14:20 +00:00
|
|
|
movePastCSLoadStoreOps(MBB, MBBI, ARM::STR, ARM::t2STRi12, 2, STI);
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, -DPRCSSize);
|
2009-07-08 18:31:39 +00:00
|
|
|
|
|
|
|
// Determine starting offsets of spill areas.
|
|
|
|
unsigned DPRCSOffset = NumBytes - (GPRCS1Size + GPRCS2Size + DPRCSSize);
|
|
|
|
unsigned GPRCS2Offset = DPRCSOffset + DPRCSSize;
|
|
|
|
unsigned GPRCS1Offset = GPRCS2Offset + GPRCS2Size;
|
2010-08-10 19:30:19 +00:00
|
|
|
if (HasFP)
|
2010-03-04 21:42:36 +00:00
|
|
|
AFI->setFramePtrSpillOffset(MFI->getObjectOffset(FramePtrSpillFI) +
|
|
|
|
NumBytes);
|
2009-07-08 18:31:39 +00:00
|
|
|
AFI->setGPRCalleeSavedArea1Offset(GPRCS1Offset);
|
|
|
|
AFI->setGPRCalleeSavedArea2Offset(GPRCS2Offset);
|
|
|
|
AFI->setDPRCalleeSavedAreaOffset(DPRCSOffset);
|
|
|
|
|
2009-11-09 00:11:35 +00:00
|
|
|
movePastCSLoadStoreOps(MBB, MBBI, ARM::VSTRD, 0, 3, STI);
|
2009-07-08 18:31:39 +00:00
|
|
|
NumBytes = DPRCSOffset;
|
|
|
|
if (NumBytes) {
|
2009-11-04 22:41:00 +00:00
|
|
|
// Adjust SP after all the callee-save spills.
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, -NumBytes);
|
2010-08-10 19:30:19 +00:00
|
|
|
if (HasFP)
|
|
|
|
AFI->setShouldRestoreSPFromFP(true);
|
2009-07-08 18:31:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (STI.isTargetELF() && hasFP(MF)) {
|
|
|
|
MFI->setOffsetAdjustment(MFI->getOffsetAdjustment() -
|
|
|
|
AFI->getFramePtrSpillOffset());
|
2010-08-10 19:30:19 +00:00
|
|
|
AFI->setShouldRestoreSPFromFP(true);
|
2009-07-08 18:31:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
AFI->setGPRCalleeSavedArea1Size(GPRCS1Size);
|
|
|
|
AFI->setGPRCalleeSavedArea2Size(GPRCS2Size);
|
|
|
|
AFI->setDPRCalleeSavedAreaSize(DPRCSSize);
|
2009-10-27 22:45:39 +00:00
|
|
|
|
|
|
|
// If we need dynamic stack realignment, do it here.
|
|
|
|
if (needsStackRealignment(MF)) {
|
|
|
|
unsigned MaxAlign = MFI->getMaxAlignment();
|
|
|
|
assert (!AFI->isThumb1OnlyFunction());
|
2009-12-06 22:39:50 +00:00
|
|
|
if (!AFI->isThumbFunction()) {
|
|
|
|
// Emit bic sp, sp, MaxAlign
|
|
|
|
AddDefaultCC(AddDefaultPred(BuildMI(MBB, MBBI, dl,
|
|
|
|
TII.get(ARM::BICri), ARM::SP)
|
2009-10-27 22:45:39 +00:00
|
|
|
.addReg(ARM::SP, RegState::Kill)
|
|
|
|
.addImm(MaxAlign-1)));
|
2009-12-06 22:39:50 +00:00
|
|
|
} else {
|
|
|
|
// We cannot use sp as source/dest register here, thus we're emitting the
|
|
|
|
// following sequence:
|
|
|
|
// mov r4, sp
|
|
|
|
// bic r4, r4, MaxAlign
|
|
|
|
// mov sp, r4
|
|
|
|
// FIXME: It will be better just to find spare register here.
|
2009-12-22 18:49:55 +00:00
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVgpr2tgpr), ARM::R4)
|
2009-12-06 22:39:50 +00:00
|
|
|
.addReg(ARM::SP, RegState::Kill);
|
|
|
|
AddDefaultCC(AddDefaultPred(BuildMI(MBB, MBBI, dl,
|
|
|
|
TII.get(ARM::t2BICri), ARM::R4)
|
|
|
|
.addReg(ARM::R4, RegState::Kill)
|
|
|
|
.addImm(MaxAlign-1)));
|
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVtgpr2gpr), ARM::SP)
|
|
|
|
.addReg(ARM::R4, RegState::Kill);
|
|
|
|
}
|
2010-08-10 19:30:19 +00:00
|
|
|
|
|
|
|
AFI->setShouldRestoreSPFromFP(true);
|
2009-10-27 22:45:39 +00:00
|
|
|
}
|
2010-08-10 19:30:19 +00:00
|
|
|
|
|
|
|
// If the frame has variable sized objects then the epilogue must restore
|
|
|
|
// the sp from fp.
|
|
|
|
if (!AFI->shouldRestoreSPFromFP() && MFI->hasVarSizedObjects())
|
|
|
|
AFI->setShouldRestoreSPFromFP(true);
|
2009-07-08 18:31:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool isCalleeSavedRegister(unsigned Reg, const unsigned *CSRegs) {
|
|
|
|
for (unsigned i = 0; CSRegs[i]; ++i)
|
|
|
|
if (Reg == CSRegs[i])
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-07-08 20:28:28 +00:00
|
|
|
static bool isCSRestore(MachineInstr *MI,
|
2009-08-11 15:33:49 +00:00
|
|
|
const ARMBaseInstrInfo &TII,
|
2009-07-08 20:28:28 +00:00
|
|
|
const unsigned *CSRegs) {
|
2009-11-09 00:11:35 +00:00
|
|
|
return ((MI->getOpcode() == (int)ARM::VLDRD ||
|
2009-07-27 03:14:20 +00:00
|
|
|
MI->getOpcode() == (int)ARM::LDR ||
|
|
|
|
MI->getOpcode() == (int)ARM::t2LDRi12) &&
|
2009-07-08 18:31:39 +00:00
|
|
|
MI->getOperand(1).isFI() &&
|
|
|
|
isCalleeSavedRegister(MI->getOperand(0).getReg(), CSRegs));
|
|
|
|
}
|
|
|
|
|
|
|
|
void ARMBaseRegisterInfo::
|
2009-07-27 18:31:40 +00:00
|
|
|
emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const {
|
2009-07-08 18:31:39 +00:00
|
|
|
MachineBasicBlock::iterator MBBI = prior(MBB.end());
|
2009-07-27 18:20:05 +00:00
|
|
|
assert(MBBI->getDesc().isReturn() &&
|
2009-07-08 18:31:39 +00:00
|
|
|
"Can only insert epilog into returning blocks");
|
2010-06-03 21:09:53 +00:00
|
|
|
unsigned RetOpcode = MBBI->getOpcode();
|
2009-07-08 18:31:39 +00:00
|
|
|
DebugLoc dl = MBBI->getDebugLoc();
|
|
|
|
MachineFrameInfo *MFI = MF.getFrameInfo();
|
|
|
|
ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
|
2009-07-28 05:48:47 +00:00
|
|
|
assert(!AFI->isThumb1OnlyFunction() &&
|
2010-02-23 17:16:27 +00:00
|
|
|
"This emitEpilogue does not support Thumb1!");
|
2009-07-28 05:48:47 +00:00
|
|
|
bool isARM = !AFI->isThumbFunction();
|
|
|
|
|
2009-07-08 18:31:39 +00:00
|
|
|
unsigned VARegSaveSize = AFI->getVarArgsRegSaveSize();
|
|
|
|
int NumBytes = (int)MFI->getStackSize();
|
|
|
|
|
|
|
|
if (!AFI->hasStackFrame()) {
|
|
|
|
if (NumBytes != 0)
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, NumBytes);
|
2009-07-08 18:31:39 +00:00
|
|
|
} else {
|
2009-11-09 00:11:35 +00:00
|
|
|
// Unwind MBBI to point to first LDR / VLDRD.
|
2009-07-08 18:31:39 +00:00
|
|
|
const unsigned *CSRegs = getCalleeSavedRegs();
|
|
|
|
if (MBBI != MBB.begin()) {
|
|
|
|
do
|
|
|
|
--MBBI;
|
2009-07-08 20:28:28 +00:00
|
|
|
while (MBBI != MBB.begin() && isCSRestore(MBBI, TII, CSRegs));
|
|
|
|
if (!isCSRestore(MBBI, TII, CSRegs))
|
2009-07-08 18:31:39 +00:00
|
|
|
++MBBI;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Move SP to start of FP callee save spill area.
|
|
|
|
NumBytes -= (AFI->getGPRCalleeSavedArea1Size() +
|
|
|
|
AFI->getGPRCalleeSavedArea2Size() +
|
|
|
|
AFI->getDPRCalleeSavedAreaSize());
|
|
|
|
|
2010-08-10 19:30:19 +00:00
|
|
|
// Reset SP based on frame pointer only if the stack frame extends beyond
|
|
|
|
// frame pointer stack slot or target is ELF and the function has FP.
|
|
|
|
if (AFI->shouldRestoreSPFromFP()) {
|
2009-07-08 18:31:39 +00:00
|
|
|
NumBytes = AFI->getFramePtrSpillOffset() - NumBytes;
|
2010-08-10 19:30:19 +00:00
|
|
|
if (NumBytes) {
|
|
|
|
if (isARM)
|
|
|
|
emitARMRegPlusImmediate(MBB, MBBI, dl, ARM::SP, FramePtr, -NumBytes,
|
|
|
|
ARMCC::AL, 0, TII);
|
|
|
|
else
|
|
|
|
emitT2RegPlusImmediate(MBB, MBBI, dl, ARM::SP, FramePtr, -NumBytes,
|
|
|
|
ARMCC::AL, 0, TII);
|
|
|
|
} else {
|
|
|
|
// Thumb2 or ARM.
|
|
|
|
if (isARM)
|
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(ARM::MOVr), ARM::SP)
|
|
|
|
.addReg(FramePtr).addImm((unsigned)ARMCC::AL).addReg(0).addReg(0);
|
|
|
|
else
|
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVgpr2gpr), ARM::SP)
|
|
|
|
.addReg(FramePtr);
|
2009-07-08 18:31:39 +00:00
|
|
|
}
|
2009-07-28 05:48:47 +00:00
|
|
|
} else if (NumBytes)
|
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, NumBytes);
|
2009-07-08 18:31:39 +00:00
|
|
|
|
|
|
|
// Move SP to start of integer callee save spill area 2.
|
2009-11-09 00:11:35 +00:00
|
|
|
movePastCSLoadStoreOps(MBB, MBBI, ARM::VLDRD, 0, 3, STI);
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, AFI->getDPRCalleeSavedAreaSize());
|
2009-07-08 18:31:39 +00:00
|
|
|
|
|
|
|
// Move SP to start of integer callee save spill area 1.
|
2009-07-27 03:14:20 +00:00
|
|
|
movePastCSLoadStoreOps(MBB, MBBI, ARM::LDR, ARM::t2LDRi12, 2, STI);
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, AFI->getGPRCalleeSavedArea2Size());
|
2009-07-08 18:31:39 +00:00
|
|
|
|
|
|
|
// Move SP to SP upon entry to the function.
|
2009-07-27 03:14:20 +00:00
|
|
|
movePastCSLoadStoreOps(MBB, MBBI, ARM::LDR, ARM::t2LDRi12, 1, STI);
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, AFI->getGPRCalleeSavedArea1Size());
|
2009-07-08 18:31:39 +00:00
|
|
|
}
|
|
|
|
|
2010-06-03 21:09:53 +00:00
|
|
|
if (RetOpcode == ARM::TCRETURNdi || RetOpcode == ARM::TCRETURNdiND ||
|
|
|
|
RetOpcode == ARM::TCRETURNri || RetOpcode == ARM::TCRETURNriND) {
|
|
|
|
// Tail call return: adjust the stack pointer and jump to callee.
|
|
|
|
MBBI = prior(MBB.end());
|
|
|
|
MachineOperand &JumpTarget = MBBI->getOperand(0);
|
|
|
|
|
|
|
|
// Jump to label or value in register.
|
|
|
|
if (RetOpcode == ARM::TCRETURNdi) {
|
2010-07-08 01:18:23 +00:00
|
|
|
BuildMI(MBB, MBBI, dl,
|
|
|
|
TII.get(STI.isThumb() ? ARM::TAILJMPdt : ARM::TAILJMPd)).
|
2010-06-03 21:09:53 +00:00
|
|
|
addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset(),
|
|
|
|
JumpTarget.getTargetFlags());
|
|
|
|
} else if (RetOpcode == ARM::TCRETURNdiND) {
|
2010-06-18 20:44:28 +00:00
|
|
|
BuildMI(MBB, MBBI, dl,
|
|
|
|
TII.get(STI.isThumb() ? ARM::TAILJMPdNDt : ARM::TAILJMPdND)).
|
2010-06-03 21:09:53 +00:00
|
|
|
addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset(),
|
|
|
|
JumpTarget.getTargetFlags());
|
|
|
|
} else if (RetOpcode == ARM::TCRETURNri) {
|
2010-06-15 22:08:33 +00:00
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(ARM::TAILJMPr)).
|
|
|
|
addReg(JumpTarget.getReg(), RegState::Kill);
|
2010-06-03 21:09:53 +00:00
|
|
|
} else if (RetOpcode == ARM::TCRETURNriND) {
|
2010-06-15 22:08:33 +00:00
|
|
|
BuildMI(MBB, MBBI, dl, TII.get(ARM::TAILJMPrND)).
|
|
|
|
addReg(JumpTarget.getReg(), RegState::Kill);
|
2010-06-03 21:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
MachineInstr *NewMI = prior(MBBI);
|
2010-06-15 22:08:33 +00:00
|
|
|
for (unsigned i = 1, e = MBBI->getNumOperands(); i != e; ++i)
|
2010-06-03 21:09:53 +00:00
|
|
|
NewMI->addOperand(MBBI->getOperand(i));
|
|
|
|
|
|
|
|
// Delete the pseudo instruction TCRETURN.
|
|
|
|
MBB.erase(MBBI);
|
|
|
|
}
|
|
|
|
|
2009-07-08 18:31:39 +00:00
|
|
|
if (VARegSaveSize)
|
2009-07-28 05:48:47 +00:00
|
|
|
emitSPUpdate(isARM, MBB, MBBI, dl, TII, VARegSaveSize);
|
2009-07-08 18:31:39 +00:00
|
|
|
}
|
|
|
|
|
2009-07-08 17:28:55 +00:00
|
|
|
#include "ARMGenRegisterInfo.inc"
|