#include <TCEFrameInfo.hh>

Inheritance diagram for llvm::TCEFrameInfo:

Collaboration diagram for llvm::TCEFrameInfo:

Public Member Functions
	TCEFrameInfo (TCERegisterInfo tri, const TCEInstrInfo tii, int stackAlignment)

MachineBasicBlock::iterator	eliminateCallFramePseudoInstr (MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const override

void	emitPrologue (MachineFunction &mf, MachineBasicBlock &MBB) const override

void	emitEpilogue (MachineFunction &mf, MachineBasicBlock &MBB) const override

bool	hasFP (const MachineFunction &MF) const override

int	stackAlignment () const

bool	containsCall (MachineFunction &mf) const

Private Attributes
int	stackAlignment_

const TCERegisterInfo *	tri_

const TCEInstrInfo &	tii_

Detailed Description

Definition at line 67 of file TCEFrameInfo.hh.

Constructor & Destructor Documentation

◆ TCEFrameInfo()

llvm::TCEFrameInfo::TCEFrameInfo	(	TCERegisterInfo *	tri,
		const TCEInstrInfo *	tii,
		int	stackAlignment
	)

inline

!! Important !! ************* If the last boolean parameter of the constructor is set to false, stack realignment is not allowed. This means, that every stack object having a bigger alignment than the stack's own alignment, will be reduced to have the stack's alignment.

Definition at line 76 of file TCEFrameInfo.hh.

References eliminateCallFramePseudoInstr(), emitEpilogue(), emitPrologue(), hasFP(), and llvm::TCERegisterInfo::setTFI().

                                                                                         :
 #ifdef LLVM_OLDER_THAN_10
         TargetFrameLowering(
             TargetFrameLowering::StackGrowsDown, 
             stackAlignment, 
             -stackAlignment,
             1,
             true /*false*/),
 #else
         // The -stackAlignment is local area offset.
         // Storing RA to stack consumes one slot,
         // so local are offset begins below it.
         TargetFrameLowering(
             StackGrowsDown, Align(stackAlignment), -stackAlignment),
 #endif
         tri_(tri), tii_(*tii), stackAlignment_(stackAlignment) {
             tri->setTFI(this); }

Here is the call graph for this function:

Member Function Documentation

◆ containsCall()

bool TCEFrameInfo::containsCall ( MachineFunction & mf ) const

Definition at line 140 of file TCEFrameInfo.cc.

References TCEISD::CALL, and emitPrologue().

Referenced by llvm::TCERegisterInfo::eliminateFrameIndex(), emitEpilogue(), emitPrologue(), and stackAlignment().

                                                     {
     for (MachineFunction::iterator i = mf.begin(); i != mf.end(); i++) {
         const MachineBasicBlock& mbb = *i;
         for (MachineBasicBlock::const_iterator j = mbb.begin();
              j != mbb.end(); j++){
             const MachineInstr& ins = *j;
             if (ins.getOpcode() == TCE::CALL ||
                 ins.getOpcode() == TCE::CALL_MEMrr ||
                 ins.getOpcode() == TCE::CALL_MEMri) {
                 return true;
             }
         }
     }
     return false;
 }

Here is the call graph for this function:

◆ eliminateCallFramePseudoInstr()

MachineBasicBlock::iterator TCEFrameInfo::eliminateCallFramePseudoInstr	(	MachineFunction &	MF,
		MachineBasicBlock &	MBB,
		MachineBasicBlock::iterator	I
	)		const

override

Eliminates call frame pseudo instructions.

Stack space is already reserved in caller stack.

Definition at line 71 of file TCEFrameInfo.cc.

References ERASE_INSTR_AND_RETURN, hasFP(), and tii_.

Referenced by TCEFrameInfo().

                                        {
     if (hasFP(MF)) {
         int opc = I->getOpcode();
         // convert stack down to sub
         if (opc == TCE::ADJCALLSTACKDOWN) {
 #ifdef LLVM_OLDER_THAN_5_0
             MachineOperand mo1 = I->getOperand(1);
             MachineOperand mo2 = I->getOperand(2);
 #else
             MachineOperand mo1 = I->getOperand(2);
             MachineOperand mo2 = I->getOperand(3);
 #endif
             long val = I->getOperand(0).getImm();
 
             if (val == 0) {
                 ERASE_INSTR_AND_RETURN(I);
             }
             I->setDesc(tii_.get(TCE::SUBrri));
             I->getOperand(0).ChangeToRegister(mo1.getReg(), mo1.isDef(),
                                               false/*mo.isImplicit()*/, mo1.isKill(),
                                               false/*dead*/, false/*undef*/,
                                               mo1.isDebug());
             I->getOperand(1).ChangeToRegister(mo2.getReg(), false, false, mo2.isKill(),
                                               false, false, mo2.isDebug());
             I->getOperand(2).ChangeToImmediate(val);
 
         // convert stack up to add
         } else if (opc == TCE::ADJCALLSTACKUP) {
             MachineOperand mo1 = I->getOperand(2);
             MachineOperand mo2 = I->getOperand(3);
             long val = I->getOperand(0).getImm();
             if (val == 0) {
                 ERASE_INSTR_AND_RETURN(I);
             }
             I->setDesc(tii_.get(TCE::ADDrri));
             I->getOperand(0).ChangeToRegister(mo1.getReg(), mo1.isDef(),
                                               false/*mo.isImplicit()*/, mo1.isKill(),
                                               false/*dead*/, false/*undef*/,
                                               mo1.isDebug());
             I->getOperand(1).ChangeToRegister(mo2.getReg(), false, false, mo2.isKill(),
                                               false, false, mo2.isDebug());
             I->getOperand(2).ChangeToImmediate(val);
             I->RemoveOperand(3);
         }
     } else {
         ERASE_INSTR_AND_RETURN(I);
     }
 #ifndef LLVM_OLDER_THAN_3_9
     // LLVM 3.9 wants an iterator pointing to the instruction after 
     // the replaced one.
     return I++;
 #endif
 }

Here is the call graph for this function:

◆ emitEpilogue()

void TCEFrameInfo::emitEpilogue	(	MachineFunction &	mf,
		MachineBasicBlock &	mbb
	)		const

override

Emits machine function epilogue to machine functions.

Definition at line 291 of file TCEFrameInfo.cc.

References assert, containsCall(), hasFP(), RA, stackAlignment_, and tii_.

Referenced by TCEFrameInfo().

                                                        {
 
 #if LLVM_OLDER_THAN_4_0
     MachineFrameInfo& mfi = *mf.getFrameInfo();
 #else
     MachineFrameInfo& mfi = mf.getFrameInfo();
 #endif
 
     MachineBasicBlock::iterator mbbi = std::prev(mbb.end());
 
     DebugLoc dl = mbbi->getDebugLoc();
 
     if (mbbi->getOpcode() != TCE::RETL) {
         assert(false && "ERROR: Inserting epilogue w/o return?");
     }
 
     unsigned numBytes = mfi.getStackSize();
     unsigned varBytes = numBytes;
 
     if (hasFP(mf)) {
         varBytes -= stackAlignment_;
     }
 
     // this unfortunately return true for inline asm.
     bool hasCalls = mfi.hasCalls();
     if (hasCalls) {
         // so then check again. Return false if only inline asm, no calls.
         hasCalls = containsCall(mf);
         if (hasCalls) {
             varBytes -= stackAlignment_;
         }
     }
 
     if (hasFP(mf)) {
         // move FP to SP
         BuildMI(mbb, mbbi, dl, tii_.get(TCE::MOVI32rr), TCE::SP)
             .addReg(TCE::FP)
             .setMIFlag(MachineInstr::FrameSetup);
 
         // restore old FP from stack
 #ifdef LITTLE_ENDIAN_TARGET
         BuildMI(mbb, mbbi, dl, tii_.get(TCE::LD32rr), TCE::FP)
             .addReg(TCE::FP)
             .addImm(0)
             .setMIFlag(MachineInstr::FrameSetup);
 #else
         BuildMI(mbb, mbbi, dl, tii_.get(TCE::LDWrr), TCE::FP)
             .addReg(TCE::FP)
             .addImm(0)
             .setMIFlag(MachineInstr::FrameSetup);
 #endif
 
         // Create metadata which says that this is an FP load
         MachineBasicBlock::iterator fpLoad = mbbi; fpLoad--;
 
 #ifdef LLVM_OLDER_THAN_6_0
         LLVMContext& context =
             mbb.getParent()->getFunction()->getContext();
 #else
         LLVMContext& context =
             mbb.getParent()->getFunction().getContext();
 #endif
 
         llvm::Metadata* md = llvm::MDString::get(context, "AA_CATEGORY_FP_SAVE_SLOT");
         MDNode* mdNode = MDNode::get(context, llvm::ArrayRef<llvm::Metadata*>(&md, 1));
 
         MachineOperand metaDataOperand = MachineOperand::CreateMetadata(mdNode);
         fpLoad->addOperand(metaDataOperand);
 
         // then the SP adjust
         BuildMI(mbb, mbbi, dl, tii_.get(TCE::ADDrri), TCE::SP)
             .addReg(TCE::SP)
             .addImm(stackAlignment_);
     } else {
         // no FP
         if (varBytes) {
             BuildMI(mbb, mbbi, dl, tii_.get(TCE::ADDrri), TCE::SP)
                 .addReg(TCE::SP)
                 .addImm(varBytes);
         }
     }
 
     if (hasCalls) {
         // Restore RA from stack.
 #ifdef LITTLE_ENDIAN_TARGET
         BuildMI(mbb, mbbi, dl, tii_.get(TCE::LD32RAr), TCE::RA)
             .addReg(TCE::SP)
             .addImm(0)
             .setMIFlag(MachineInstr::FrameSetup);
 #else
         BuildMI(mbb, mbbi, dl, tii_.get(TCE::LDWRAr), TCE::RA)
             .addReg(TCE::SP)
             .addImm(0)
             .setMIFlag(MachineInstr::FrameSetup);
 #endif
 
         // Create metadata which says that this is an RA load
         MachineBasicBlock::iterator raLoad = mbbi; raLoad--;
 
 
 #ifdef LLVM_OLDER_THAN_6_0
         LLVMContext& context =
             mbb.getParent()->getFunction()->getContext();
 #else
         LLVMContext& context =
             mbb.getParent()->getFunction().getContext();
 #endif
 
         llvm::Metadata* md = llvm::MDString::get(context, "AA_CATEGORY_RA_SAVE_SLOT");
         MDNode* mdNode = MDNode::get(context, llvm::ArrayRef<llvm::Metadata*>(&md, 1));
 
         MachineOperand metaDataOperand = MachineOperand::CreateMetadata(mdNode);
         raLoad->addOperand(metaDataOperand);
 
         // then the SP adjust
         BuildMI(mbb, mbbi, dl, tii_.get(TCE::ADDrri), TCE::SP)
             .addReg(TCE::SP)
             .addImm(stackAlignment_);
     }
 }

Here is the call graph for this function:

◆ emitPrologue()

void TCEFrameInfo::emitPrologue	(	MachineFunction &	mf,
		MachineBasicBlock &	MBB
	)		const

override

Emits machine function prologue to machine functions.

Definition at line 163 of file TCEFrameInfo.cc.

References containsCall(), hasFP(), RA, stackAlignment_, and tii_.

Referenced by containsCall(), and TCEFrameInfo().

        {
     MachineBasicBlock& mbb = mf.front();
 #if LLVM_OLDER_THAN_4_0
     MachineFrameInfo& mfi = *mf.getFrameInfo();
 #else
     MachineFrameInfo& mfi = mf.getFrameInfo();
 #endif
     int numBytes = (int)mfi.getStackSize();
 
     // this unfortunately return true for inline asm.
     bool hasCalls = mfi.hasCalls();
     if (hasCalls) {
         // so then check again. Return false if only inline asm, no calls.
         hasCalls = containsCall(mf);
     }
 
     // stack size alignment
     numBytes = (numBytes + (stackAlignment_-1)) & ~(stackAlignment_-1);
 
     // stack size without RA/FP storage
     int varBytes = numBytes;
 
     MachineBasicBlock::iterator ii = mbb.begin();
 
     DebugLoc dl = (ii != mbb.end() ?
                    ii->getDebugLoc() : DebugLoc());
 
     // No need to save RA if does not call anything or does no return
     // if (hasCalls && !mf.getFunction()->doesNotReturn()) {
     // However, there is a bug elsewhere and this triggers it.
     if (hasCalls) {
         BuildMI(mbb, ii, dl, tii_.get(TCE::SUBrri), TCE::SP)
             .addReg(TCE::SP)
             .addImm(stackAlignment_);
 
         // Save RA to stack.
 #ifdef LITTLE_ENDIAN_TARGET
         BuildMI(mbb, ii, dl, tii_.get(TCE::ST32RArr))
             .addReg(TCE::SP)
             .addImm(0)
             .addReg(TCE::RA)
             .setMIFlag(MachineInstr::FrameSetup);
 #else
         BuildMI(mbb, ii, dl, tii_.get(TCE::STWRArr))
             .addReg(TCE::SP)
             .addImm(0)
             .addReg(TCE::RA)
             .setMIFlag(MachineInstr::FrameSetup);
 #endif
         numBytes += stackAlignment_;
 
         // Create metadata which says that this is an RA save
         MachineBasicBlock::iterator raStore = ii; raStore--;
 #ifdef LLVM_OLDER_THAN_6_0
         LLVMContext& context = mbb.getParent()->getFunction()->getContext();
 #else
         LLVMContext& context = mbb.getParent()->getFunction().getContext();
 #endif
         llvm::Metadata* md =
             llvm::MDString::get(context, "AA_CATEGORY_RA_SAVE_SLOT");
         MDNode* mdNode =
             MDNode::get(context, llvm::ArrayRef<llvm::Metadata*>(&md, 1));
 
         MachineOperand metaDataOperand = MachineOperand::CreateMetadata(mdNode);
         raStore->addOperand(metaDataOperand);
     }
 
     if (hasFP(mf)) {
         // only need to save old FP if this function may return
 #ifdef LLVM_OLDER_THAN_6_0
         if (!mf.getFunction()->doesNotReturn()) {
 #else
         if (!mf.getFunction().doesNotReturn()) {
 #endif
             BuildMI(mbb, ii, dl, tii_.get(TCE::SUBrri), TCE::SP)
                 .addReg(TCE::SP)
                 .addImm(stackAlignment_);
 
 #ifdef LITTLE_ENDIAN_TARGET
             BuildMI(mbb, ii, dl, tii_.get(TCE::ST32rr))
                 .addReg(TCE::SP)
                 .addImm(0)
                 .addReg(TCE::FP)
                 .setMIFlag(MachineInstr::FrameSetup);
 #else
             BuildMI(mbb, ii, dl, tii_.get(TCE::STWrr))
                 .addReg(TCE::SP)
                 .addImm(0)
                 .addReg(TCE::FP)
                 .setMIFlag(MachineInstr::FrameSetup);
 #endif
             numBytes += stackAlignment_;
             // Create metadata which says that this is an FP save
             MachineBasicBlock::iterator fpStore = ii; fpStore--;
 #ifdef LLVM_OLDER_THAN_6_0
             LLVMContext& context = mbb.getParent()->getFunction()->getContext();
 #else
             LLVMContext& context = mbb.getParent()->getFunction().getContext();
 #endif
             llvm::Metadata* md =
                 llvm::MDString::get(context, "AA_CATEGORY_FP_SAVE_SLOT");
             MDNode* mdNode =
                 MDNode::get(context, llvm::ArrayRef<llvm::Metadata*>(&md, 1));
 
             MachineOperand metaDataOperand = MachineOperand::CreateMetadata(mdNode);
             fpStore->addOperand(metaDataOperand);
         }
         // if FP used by this function, move SP to FP
         BuildMI(mbb, ii, dl, tii_.get(TCE::MOVI32rr), TCE::FP).addReg(TCE::SP)
             .setMIFlag(MachineInstr::FrameSetup);
     }
 
     mfi.setStackSize(numBytes);
 
     // Adjust stack pointer
     if (varBytes != 0) {
         BuildMI(mbb, ii, dl, tii_.get(TCE::SUBrri), TCE::SP)
             .addReg(TCE::SP)
             .addImm(varBytes);
     }
 }

Here is the call graph for this function:

◆ hasFP()

bool TCEFrameInfo::hasFP ( const MachineFunction & MF ) const

override

Definition at line 128 of file TCEFrameInfo.cc.

Referenced by eliminateCallFramePseudoInstr(), llvm::TCERegisterInfo::eliminateFrameIndex(), emitEpilogue(), emitPrologue(), llvm::TCERegisterInfo::hasFP(), and TCEFrameInfo().

                                                         {
 #if LLVM_OLDER_THAN_4_0
     if (MF.getFrameInfo()->hasVarSizedObjects()) {
 #else
     if (MF.getFrameInfo().hasVarSizedObjects()) {
 #endif
         return true;
     }
     return false;
 }