llvm/lib/Target/LoongArch/LoongArchFrameLowering.cpp - rust-lang/llvm-project - Git at Google

 //===-- LoongArchFrameLowering.cpp - LoongArch Frame Information -*- C++ -*-==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the LoongArch implementation of TargetFrameLowering class.
 //
 //===----------------------------------------------------------------------===//

 #include "LoongArchFrameLowering.h"
 #include "LoongArchMachineFunctionInfo.h"
 #include "LoongArchSubtarget.h"
 #include "MCTargetDesc/LoongArchBaseInfo.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/RegisterScavenging.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/MC/MCDwarf.h"

 using namespace llvm;

 #define DEBUG_TYPE "loongarch-frame-lowering"

 // Return true if the specified function should have a dedicated frame
 // pointer register.  This is true if frame pointer elimination is
 // disabled, if it needs dynamic stack realignment, if the function has
 // variable sized allocas, or if the frame address is taken.
 bool LoongArchFrameLowering::hasFP(const MachineFunction &MF) const {
   const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();

   const MachineFrameInfo &MFI = MF.getFrameInfo();
   return MF.getTarget().Options.DisableFramePointerElim(MF) ||
          RegInfo->hasStackRealignment(MF) || MFI.hasVarSizedObjects() ||
          MFI.isFrameAddressTaken();
 }

 bool LoongArchFrameLowering::hasBP(const MachineFunction &MF) const {
   const MachineFrameInfo &MFI = MF.getFrameInfo();
   const TargetRegisterInfo *TRI = STI.getRegisterInfo();

   return MFI.hasVarSizedObjects() && TRI->hasStackRealignment(MF);
 }

 void LoongArchFrameLowering::adjustReg(MachineBasicBlock &MBB,
                                        MachineBasicBlock::iterator MBBI,
                                        const DebugLoc &DL, Register DestReg,
                                        Register SrcReg, int64_t Val,
                                        MachineInstr::MIFlag Flag) const {
   const LoongArchInstrInfo *TII = STI.getInstrInfo();
   bool IsLA64 = STI.is64Bit();

   if (DestReg == SrcReg && Val == 0)
     return;

   if (isInt<12>(Val)) {
     // addi.w/d $DstReg, $SrcReg, Val
     BuildMI(MBB, MBBI, DL,
             TII->get(IsLA64 ? LoongArch::ADDI_D : LoongArch::ADDI_W), DestReg)
         .addReg(SrcReg)
         .addImm(Val)
         .setMIFlag(Flag);
     return;
   }

   report_fatal_error("adjustReg cannot yet handle adjustments >12 bits");
 }

 // Determine the size of the frame and maximum call frame size.
 void LoongArchFrameLowering::determineFrameLayout(MachineFunction &MF) const {
   MachineFrameInfo &MFI = MF.getFrameInfo();

   // Get the number of bytes to allocate from the FrameInfo.
   uint64_t FrameSize = MFI.getStackSize();

   // Make sure the frame is aligned.
   FrameSize = alignTo(FrameSize, getStackAlign());

   // Update frame info.
   MFI.setStackSize(FrameSize);
 }

 void LoongArchFrameLowering::emitPrologue(MachineFunction &MF,
                                           MachineBasicBlock &MBB) const {
   MachineFrameInfo &MFI = MF.getFrameInfo();
   const LoongArchRegisterInfo *RI = STI.getRegisterInfo();
   const LoongArchInstrInfo *TII = STI.getInstrInfo();
   MachineBasicBlock::iterator MBBI = MBB.begin();

   Register SPReg = LoongArch::R3;
   Register FPReg = LoongArch::R22;

   // Debug location must be unknown since the first debug location is used
   // to determine the end of the prologue.
   DebugLoc DL;

   // Determine the correct frame layout
   determineFrameLayout(MF);

   // First, compute final stack size.
   uint64_t StackSize = MFI.getStackSize();

   // Early exit if there is no need to allocate space in the stack.
   if (StackSize == 0 && !MFI.adjustsStack())
     return;

   // Adjust stack.
   adjustReg(MBB, MBBI, DL, SPReg, SPReg, -StackSize, MachineInstr::FrameSetup);
   // Emit ".cfi_def_cfa_offset StackSize".
   unsigned CFIIndex =
       MF.addFrameInst(MCCFIInstruction::cfiDefCfaOffset(nullptr, StackSize));
   BuildMI(MBB, MBBI, DL, TII->get(TargetOpcode::CFI_INSTRUCTION))
       .addCFIIndex(CFIIndex)
       .setMIFlag(MachineInstr::FrameSetup);

   const auto &CSI = MFI.getCalleeSavedInfo();

   // The frame pointer is callee-saved, and code has been generated for us to
   // save it to the stack. We need to skip over the storing of callee-saved
   // registers as the frame pointer must be modified after it has been saved
   // to the stack, not before.
   std::advance(MBBI, CSI.size());

   // Iterate over list of callee-saved registers and emit .cfi_offset
   // directives.
   for (const auto &Entry : CSI) {
     int64_t Offset = MFI.getObjectOffset(Entry.getFrameIdx());
     unsigned CFIIndex = MF.addFrameInst(MCCFIInstruction::createOffset(
         nullptr, RI->getDwarfRegNum(Entry.getReg(), true), Offset));
     BuildMI(MBB, MBBI, DL, TII->get(TargetOpcode::CFI_INSTRUCTION))
         .addCFIIndex(CFIIndex)
         .setMIFlag(MachineInstr::FrameSetup);
   }

   // Generate new FP.
   if (hasFP(MF)) {
     adjustReg(MBB, MBBI, DL, FPReg, SPReg, StackSize, MachineInstr::FrameSetup);

     // Emit ".cfi_def_cfa $fp, 0"
     unsigned CFIIndex = MF.addFrameInst(MCCFIInstruction::cfiDefCfa(
         nullptr, RI->getDwarfRegNum(FPReg, true), 0));
     BuildMI(MBB, MBBI, DL, TII->get(TargetOpcode::CFI_INSTRUCTION))
         .addCFIIndex(CFIIndex)
         .setMIFlag(MachineInstr::FrameSetup);
   }
 }

 void LoongArchFrameLowering::emitEpilogue(MachineFunction &MF,
                                           MachineBasicBlock &MBB) const {
   const LoongArchRegisterInfo *RI = STI.getRegisterInfo();
   MachineFrameInfo &MFI = MF.getFrameInfo();
   Register SPReg = LoongArch::R3;

   MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
   DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();

   const auto &CSI = MFI.getCalleeSavedInfo();
   // Skip to before the restores of callee-saved registers.
   auto LastFrameDestroy = MBBI;
   if (!CSI.empty())
     LastFrameDestroy = std::prev(MBBI, CSI.size());

   // Get the number of bytes from FrameInfo.
   uint64_t StackSize = MFI.getStackSize();

   // Restore the stack pointer.
   if (RI->hasStackRealignment(MF) || MFI.hasVarSizedObjects()) {
     assert(hasFP(MF) && "frame pointer should not have been eliminated");
     adjustReg(MBB, LastFrameDestroy, DL, SPReg, LoongArch::R22, -StackSize,
               MachineInstr::FrameDestroy);
   }

   // Deallocate stack
   adjustReg(MBB, MBBI, DL, SPReg, SPReg, StackSize, MachineInstr::FrameDestroy);
 }

 void LoongArchFrameLowering::determineCalleeSaves(MachineFunction &MF,
                                                   BitVector &SavedRegs,
                                                   RegScavenger *RS) const {
   TargetFrameLowering::determineCalleeSaves(MF, SavedRegs, RS);
   // Unconditionally spill RA and FP only if the function uses a frame
   // pointer.
   if (hasFP(MF)) {
     SavedRegs.set(LoongArch::R1);
     SavedRegs.set(LoongArch::R22);
   }
   // Mark BP as used if function has dedicated base pointer.
   if (hasBP(MF))
     SavedRegs.set(LoongArchABI::getBPReg());
 }

 StackOffset LoongArchFrameLowering::getFrameIndexReference(
     const MachineFunction &MF, int FI, Register &FrameReg) const {
   const MachineFrameInfo &MFI = MF.getFrameInfo();
   const TargetRegisterInfo *RI = MF.getSubtarget().getRegisterInfo();

   // Callee-saved registers should be referenced relative to the stack
   // pointer (positive offset), otherwise use the frame pointer (negative
   // offset).
   const auto &CSI = MFI.getCalleeSavedInfo();
   int MinCSFI = 0;
   int MaxCSFI = -1;
   StackOffset Offset =
       StackOffset::getFixed(MFI.getObjectOffset(FI) - getOffsetOfLocalArea() +
                             MFI.getOffsetAdjustment());

   if (CSI.size()) {
     MinCSFI = CSI[0].getFrameIdx();
     MaxCSFI = CSI[CSI.size() - 1].getFrameIdx();
   }

   FrameReg = RI->getFrameRegister(MF);
   if ((FI >= MinCSFI && FI <= MaxCSFI) || !hasFP(MF)) {
     FrameReg = LoongArch::R3;
     Offset += StackOffset::getFixed(MFI.getStackSize());
   }

   return Offset;
 }
	//===-- LoongArchFrameLowering.cpp - LoongArch Frame Information -- C++ --==//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file contains the LoongArch implementation of TargetFrameLowering class.
	//
	//===----------------------------------------------------------------------===//

	#include "LoongArchFrameLowering.h"
	#include "LoongArchMachineFunctionInfo.h"
	#include "LoongArchSubtarget.h"
	#include "MCTargetDesc/LoongArchBaseInfo.h"
	#include "llvm/CodeGen/MachineFrameInfo.h"
	#include "llvm/CodeGen/MachineFunction.h"
	#include "llvm/CodeGen/MachineInstrBuilder.h"
	#include "llvm/CodeGen/MachineRegisterInfo.h"
	#include "llvm/CodeGen/RegisterScavenging.h"
	#include "llvm/IR/DiagnosticInfo.h"
	#include "llvm/MC/MCDwarf.h"

	using namespace llvm;

	#define DEBUG_TYPE "loongarch-frame-lowering"

	// Return true if the specified function should have a dedicated frame
	// pointer register. This is true if frame pointer elimination is
	// disabled, if it needs dynamic stack realignment, if the function has
	// variable sized allocas, or if the frame address is taken.
	bool LoongArchFrameLowering::hasFP(const MachineFunction &MF) const {
	const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();

	const MachineFrameInfo &MFI = MF.getFrameInfo();
	return MF.getTarget().Options.DisableFramePointerElim(MF) \|\|
	RegInfo->hasStackRealignment(MF) \|\| MFI.hasVarSizedObjects() \|\|
	MFI.isFrameAddressTaken();
	}

	bool LoongArchFrameLowering::hasBP(const MachineFunction &MF) const {
	const MachineFrameInfo &MFI = MF.getFrameInfo();
	const TargetRegisterInfo *TRI = STI.getRegisterInfo();

	return MFI.hasVarSizedObjects() && TRI->hasStackRealignment(MF);
	}

	void LoongArchFrameLowering::adjustReg(MachineBasicBlock &MBB,
	MachineBasicBlock::iterator MBBI,
	const DebugLoc &DL, Register DestReg,
	Register SrcReg, int64_t Val,
	MachineInstr::MIFlag Flag) const {
	const LoongArchInstrInfo *TII = STI.getInstrInfo();
	bool IsLA64 = STI.is64Bit();

	if (DestReg == SrcReg && Val == 0)
	return;

	if (isInt<12>(Val)) {
	// addi.w/d $DstReg, $SrcReg, Val
	BuildMI(MBB, MBBI, DL,
	TII->get(IsLA64 ? LoongArch::ADDI_D : LoongArch::ADDI_W), DestReg)
	.addReg(SrcReg)
	.addImm(Val)
	.setMIFlag(Flag);
	return;
	}

	report_fatal_error("adjustReg cannot yet handle adjustments >12 bits");
	}

	// Determine the size of the frame and maximum call frame size.
	void LoongArchFrameLowering::determineFrameLayout(MachineFunction &MF) const {
	MachineFrameInfo &MFI = MF.getFrameInfo();

	// Get the number of bytes to allocate from the FrameInfo.
	uint64_t FrameSize = MFI.getStackSize();

	// Make sure the frame is aligned.
	FrameSize = alignTo(FrameSize, getStackAlign());

	// Update frame info.
	MFI.setStackSize(FrameSize);
	}

	void LoongArchFrameLowering::emitPrologue(MachineFunction &MF,
	MachineBasicBlock &MBB) const {
	MachineFrameInfo &MFI = MF.getFrameInfo();
	const LoongArchRegisterInfo *RI = STI.getRegisterInfo();
	const LoongArchInstrInfo *TII = STI.getInstrInfo();
	MachineBasicBlock::iterator MBBI = MBB.begin();

	Register SPReg = LoongArch::R3;
	Register FPReg = LoongArch::R22;

	// Debug location must be unknown since the first debug location is used
	// to determine the end of the prologue.
	DebugLoc DL;

	// Determine the correct frame layout
	determineFrameLayout(MF);

	// First, compute final stack size.
	uint64_t StackSize = MFI.getStackSize();

	// Early exit if there is no need to allocate space in the stack.
	if (StackSize == 0 && !MFI.adjustsStack())
	return;

	// Adjust stack.
	adjustReg(MBB, MBBI, DL, SPReg, SPReg, -StackSize, MachineInstr::FrameSetup);
	// Emit ".cfi_def_cfa_offset StackSize".
	unsigned CFIIndex =
	MF.addFrameInst(MCCFIInstruction::cfiDefCfaOffset(nullptr, StackSize));
	BuildMI(MBB, MBBI, DL, TII->get(TargetOpcode::CFI_INSTRUCTION))
	.addCFIIndex(CFIIndex)
	.setMIFlag(MachineInstr::FrameSetup);

	const auto &CSI = MFI.getCalleeSavedInfo();

	// The frame pointer is callee-saved, and code has been generated for us to
	// save it to the stack. We need to skip over the storing of callee-saved
	// registers as the frame pointer must be modified after it has been saved
	// to the stack, not before.
	std::advance(MBBI, CSI.size());

	// Iterate over list of callee-saved registers and emit .cfi_offset
	// directives.
	for (const auto &Entry : CSI) {
	int64_t Offset = MFI.getObjectOffset(Entry.getFrameIdx());
	unsigned CFIIndex = MF.addFrameInst(MCCFIInstruction::createOffset(
	nullptr, RI->getDwarfRegNum(Entry.getReg(), true), Offset));
	BuildMI(MBB, MBBI, DL, TII->get(TargetOpcode::CFI_INSTRUCTION))
	.addCFIIndex(CFIIndex)
	.setMIFlag(MachineInstr::FrameSetup);
	}

	// Generate new FP.
	if (hasFP(MF)) {
	adjustReg(MBB, MBBI, DL, FPReg, SPReg, StackSize, MachineInstr::FrameSetup);

	// Emit ".cfi_def_cfa $fp, 0"
	unsigned CFIIndex = MF.addFrameInst(MCCFIInstruction::cfiDefCfa(
	nullptr, RI->getDwarfRegNum(FPReg, true), 0));
	BuildMI(MBB, MBBI, DL, TII->get(TargetOpcode::CFI_INSTRUCTION))
	.addCFIIndex(CFIIndex)
	.setMIFlag(MachineInstr::FrameSetup);
	}
	}

	void LoongArchFrameLowering::emitEpilogue(MachineFunction &MF,
	MachineBasicBlock &MBB) const {
	const LoongArchRegisterInfo *RI = STI.getRegisterInfo();
	MachineFrameInfo &MFI = MF.getFrameInfo();
	Register SPReg = LoongArch::R3;

	MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
	DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();

	const auto &CSI = MFI.getCalleeSavedInfo();
	// Skip to before the restores of callee-saved registers.
	auto LastFrameDestroy = MBBI;
	if (!CSI.empty())
	LastFrameDestroy = std::prev(MBBI, CSI.size());

	// Get the number of bytes from FrameInfo.
	uint64_t StackSize = MFI.getStackSize();

	// Restore the stack pointer.
	if (RI->hasStackRealignment(MF) \|\| MFI.hasVarSizedObjects()) {
	assert(hasFP(MF) && "frame pointer should not have been eliminated");
	adjustReg(MBB, LastFrameDestroy, DL, SPReg, LoongArch::R22, -StackSize,
	MachineInstr::FrameDestroy);
	}

	// Deallocate stack
	adjustReg(MBB, MBBI, DL, SPReg, SPReg, StackSize, MachineInstr::FrameDestroy);
	}

	void LoongArchFrameLowering::determineCalleeSaves(MachineFunction &MF,
	BitVector &SavedRegs,
	RegScavenger *RS) const {
	TargetFrameLowering::determineCalleeSaves(MF, SavedRegs, RS);
	// Unconditionally spill RA and FP only if the function uses a frame
	// pointer.
	if (hasFP(MF)) {
	SavedRegs.set(LoongArch::R1);
	SavedRegs.set(LoongArch::R22);
	}
	// Mark BP as used if function has dedicated base pointer.
	if (hasBP(MF))
	SavedRegs.set(LoongArchABI::getBPReg());
	}

	StackOffset LoongArchFrameLowering::getFrameIndexReference(
	const MachineFunction &MF, int FI, Register &FrameReg) const {
	const MachineFrameInfo &MFI = MF.getFrameInfo();
	const TargetRegisterInfo *RI = MF.getSubtarget().getRegisterInfo();

	// Callee-saved registers should be referenced relative to the stack
	// pointer (positive offset), otherwise use the frame pointer (negative
	// offset).
	const auto &CSI = MFI.getCalleeSavedInfo();
	int MinCSFI = 0;
	int MaxCSFI = -1;
	StackOffset Offset =
	StackOffset::getFixed(MFI.getObjectOffset(FI) - getOffsetOfLocalArea() +
	MFI.getOffsetAdjustment());

	if (CSI.size()) {
	MinCSFI = CSI[0].getFrameIdx();
	MaxCSFI = CSI[CSI.size() - 1].getFrameIdx();
	}

	FrameReg = RI->getFrameRegister(MF);
	if ((FI >= MinCSFI && FI <= MaxCSFI) \|\| !hasFP(MF)) {
	FrameReg = LoongArch::R3;
	Offset += StackOffset::getFixed(MFI.getStackSize());
	}

	return Offset;
	}