#include <TCEFrameInfo.hh>

Inheritance diagram for llvm::TCEFrameLowering:

Collaboration diagram for llvm::TCEFrameLowering:

Public Member Functions
	TCEFrameLowering (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 (const MachineFunction &mf) const

Private Attributes
int	stackAlignment_

const TCERegisterInfo *	tri_

const TCEInstrInfo &	tii_

Detailed Description

!! Important !! ************* ON EVERY LLVM UPDATE CHECK THESE INTERFACES VERY CAREFULLY FROM include/llvm/Target/TargetFrameInfo.h

Compiler doesn warn or give error if parameter lists are changed. Many times also base class implementation works, but does not do very good job.

Definition at line 60 of file TCEFrameInfo.hh.

Constructor & Destructor Documentation

◆ TCEFrameLowering()

llvm::TCEFrameLowering::TCEFrameLowering	(	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.

For example, if stack realignment parameter is set to false, and stack has alignment of 4, and v4i32 vector has alignment of 16 (bytes) -> vector's alignment in stack will be demoted to 4.

Definition at line 73 of file TCEFrameInfo.hh.

                                 :
         // 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),
         tri_(tri), tii_(*tii), stackAlignment_(stackAlignment) {
             tri->setTFI(this);
         }

References llvm::TCERegisterInfo::setTFI().

Here is the call graph for this function:

Member Function Documentation

◆ containsCall()

bool TCEFrameLowering::containsCall ( const MachineFunction & mf ) const

Definition at line 146 of file TCEFrameInfo.cc.

                                                               {
     for (MachineFunction::const_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;
 }

References TCEISD::CALL.

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

◆ eliminateCallFramePseudoInstr()

MachineBasicBlock::iterator TCEFrameLowering::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 85 of file TCEFrameInfo.cc.

                                        {
     if (hasFP(MF)) {
         int opc = I->getOpcode();
         // convert stack down to sub
         if (opc == TCE::ADJCALLSTACKDOWN) {
             MachineOperand mo1 = I->getOperand(2);
             MachineOperand mo2 = I->getOperand(3);
             long val = I->getOperand(0).getImm();
  
             if (val == 0) {
                 ERASE_INSTR_AND_RETURN(I);
             }
             auto spOpcAndOffset = tii_.getPointerAdjustment(-val);
             I->setDesc(tii_.get(std::get<0>(spOpcAndOffset)));
             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(std::get<1>(spOpcAndOffset));
  
         // 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(ADDIMM));
             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);
             #ifdef LLVM_OLDER_THAN_15
             I->RemoveOperand(3);
             #else
             I->removeOperand(3);
             #endif
         }
     } else {
         ERASE_INSTR_AND_RETURN(I);
     }
     return I;
 }

References ADDIMM, ERASE_INSTR_AND_RETURN, llvm::TCEInstrInfo::getPointerAdjustment(), hasFP(), and tii_.

Here is the call graph for this function:

◆ emitEpilogue()

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

override

Emits machine function epilogue to machine functions.

Definition at line 266 of file TCEFrameInfo.cc.

                                                        {
  
     MachineFrameInfo& mfi = mf.getFrameInfo();
  
     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();
     numBytes = (numBytes + (stackAlignment_-1)) & ~(stackAlignment_-1);
     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(MOVREG), TCE::SP)
             .addReg(TCE::FP)
             .setMIFlag(MachineInstr::FrameSetup);
  
         // restore old FP from stack
         BuildMI(mbb, mbbi, dl, tii_.get(LDREG), TCE::FP)
             .addReg(TCE::FP)
             .addImm(0)
             .setMIFlag(MachineInstr::FrameSetup);
  
         // Create metadata which says that this is an FP load
         MachineBasicBlock::iterator fpLoad = mbbi; fpLoad--;
  
         LLVMContext& context =
             mbb.getParent()->getFunction().getContext();
  
         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(ADDIMM), TCE::SP)
             .addReg(TCE::SP)
             .addImm(stackAlignment_);
     } else {
         // no FP
         if (varBytes) {
             BuildMI(mbb, mbbi, dl, tii_.get(ADDIMM), TCE::SP)
                 .addReg(TCE::SP)
                 .addImm(varBytes);
         }
     }
  
     if (hasCalls) {
         // Restore RA from stack.
         BuildMI(mbb, mbbi, dl, tii_.get(LDRA), TCE::RA)
             .addReg(TCE::SP)
             .addImm(0)
             .setMIFlag(MachineInstr::FrameSetup);
         // Create metadata which says that this is an RA load
         MachineBasicBlock::iterator raLoad = mbbi; raLoad--;
  
         LLVMContext& context =
             mbb.getParent()->getFunction().getContext();
  
         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(ADDIMM), TCE::SP)
             .addReg(TCE::SP)
             .addImm(stackAlignment_);
     }
 }

References ADDIMM, assert, containsCall(), hasFP(), LDRA, LDREG, MOVREG, RA, stackAlignment_, and tii_.

Here is the call graph for this function:

◆ emitPrologue()

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

override

Emits machine function prologue to machine functions.

Definition at line 166 of file TCEFrameInfo.cc.

        {
     MachineBasicBlock& mbb = mf.front();
     MachineFrameInfo& mfi = mf.getFrameInfo();
     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) {
         auto spOpcAndOffset = tii_.getPointerAdjustment(-stackAlignment_);
         BuildMI(mbb, ii, dl, tii_.get(std::get<0>(spOpcAndOffset)), TCE::SP)
             .addReg(TCE::SP)
             .addImm(std::get<1>(spOpcAndOffset));
  
         // Save RA to stack.
         BuildMI(mbb, ii, dl, tii_.get(STRA))
             .addReg(TCE::SP)
             .addImm(0)
             .addReg(TCE::RA)
             .setMIFlag(MachineInstr::FrameSetup);
         numBytes += stackAlignment_;
  
         // Create metadata which says that this is an RA save
         MachineBasicBlock::iterator raStore = ii; raStore--;
         LLVMContext& context = mbb.getParent()->getFunction().getContext();
         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
         if (!mf.getFunction().doesNotReturn()) {
             auto spOpcAndOffset = tii_.getPointerAdjustment(-stackAlignment_);
             BuildMI(mbb, ii, dl, tii_.get(std::get<0>(spOpcAndOffset)),
                     TCE::SP)
                 .addReg(TCE::SP)
                 .addImm(std::get<1>(spOpcAndOffset));
  
             BuildMI(mbb, ii, dl, tii_.get(STREG))
                 .addReg(TCE::SP)
                 .addImm(0)
                 .addReg(TCE::FP)
                 .setMIFlag(MachineInstr::FrameSetup);
  
             numBytes += stackAlignment_;
             // Create metadata which says that this is an FP save
             MachineBasicBlock::iterator fpStore = ii; fpStore--;
             LLVMContext& context = mbb.getParent()->getFunction().getContext();
             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(MOVREG), TCE::FP).addReg(TCE::SP)
             .setMIFlag(MachineInstr::FrameSetup);
     }
  
     mfi.setStackSize(numBytes);
  
     // Adjust stack pointer
     if (varBytes != 0) {
         auto spOpcAndOffset = tii_.getPointerAdjustment(-varBytes);
         BuildMI(mbb, ii, dl, tii_.get(std::get<0>(spOpcAndOffset)), TCE::SP)
             .addReg(TCE::SP)
             .addImm(std::get<1>(spOpcAndOffset));
     }
 }

References containsCall(), llvm::TCEInstrInfo::getPointerAdjustment(), hasFP(), MOVREG, RA, stackAlignment_, STRA, STREG, and tii_.

Here is the call graph for this function:

◆ hasFP()

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

override

Definition at line 138 of file TCEFrameInfo.cc.

                                                             {
     if (MF.getFrameInfo().hasVarSizedObjects()) {
         return true;
     }
     return false;
 }

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

◆ stackAlignment()

int llvm::TCEFrameLowering::stackAlignment ( ) const

inline

Definition at line 95 of file TCEFrameInfo.hh.

95 { return stackAlignment_; }

References stackAlignment_.

Referenced by llvm::TCERegisterInfo::eliminateFrameIndex().

Member Data Documentation

◆ stackAlignment_

int llvm::TCEFrameLowering::stackAlignment_

private

Definition at line 98 of file TCEFrameInfo.hh.

Referenced by emitEpilogue(), emitPrologue(), and stackAlignment().

◆ tii_

const TCEInstrInfo& llvm::TCEFrameLowering::tii_

private

Definition at line 100 of file TCEFrameInfo.hh.

Referenced by eliminateCallFramePseudoInstr(), emitEpilogue(), and emitPrologue().

◆ tri_

const TCERegisterInfo* llvm::TCEFrameLowering::tri_

private

Definition at line 99 of file TCEFrameInfo.hh.

The documentation for this class was generated from the following files:

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TCEFrameLowering()

Member Function Documentation

◆ containsCall()

◆ eliminateCallFramePseudoInstr()

◆ emitEpilogue()

◆ emitPrologue()

◆ hasFP()

◆ stackAlignment()

Member Data Documentation

◆ stackAlignment_

◆ tii_

◆ tri_