LoongArchFrameLowering.cpp Source File (original) (raw)

26using namespace llvm;

28#define DEBUG_TYPE "loongarch-frame-lowering"

56 bool IsLA64 = STI.is64Bit();

57 unsigned Addi = IsLA64 ? LoongArch::ADDI_D : LoongArch::ADDI_W;

59 if (DestReg == SrcReg && Val == 0)

60 return;

68 return;

69 }

79 if (Val > -4096 && Val <= (2 * MaxPosAdjStep)) {

80 int64_t FirstAdj = Val < 0 ? -2048 : MaxPosAdjStep;

81 Val -= FirstAdj;

90 return;

91 }

93 unsigned Opc = IsLA64 ? LoongArch::ADD_D : LoongArch::ADD_W;

94 if (Val < 0) {

95 Val = -Val;

96 Opc = IsLA64 ? LoongArch::SUB_D : LoongArch::SUB_W;

97 }

100 Register ScratchReg = MRI.createVirtualRegister(&LoongArch::GPRRegClass);

101 TII->movImm(MBB, MBBI, DL, ScratchReg, Val, Flag);

106}

107

108

109void LoongArchFrameLowering::determineFrameLayout(MachineFunction &MF) const {

111

112

114

115

117

118

120}

121

125 for (auto &MBB : MF)

126 for (auto &MI : MBB)

127 FuncSize += TII->getInstSizeInBytes(MI);

128 return FuncSize;

129}

130

133 return false;

134 for (auto &MBB : MF)

135 for (auto &MI : MBB)

136 if (MI.getOpcode() == LoongArch::PseudoST_CFR)

137 return true;

138 return false;

139}

140

149

150 unsigned ScavSlotsNum = 0;

151

152

153

155 if (IsLargeFunction)

156 ScavSlotsNum = 1;

157

158

159

160

161

162

163 unsigned EstimateStackSize = MFI.estimateStackSize(MF);

164 if ( isInt<11> (EstimateStackSize) ||

166 isInt<7> (EstimateStackSize)))

167 ScavSlotsNum = std::max(ScavSlotsNum, 1u);

168

169

171 ++ScavSlotsNum;

172

173

174 for (unsigned i = 0; i < ScavSlotsNum; ++i) {

175 int FI =

176 MFI.CreateSpillStackObject(RI->getSpillSize(RC), RI->getSpillAlign(RC));

177 RS->addScavengingFrameIndex(FI);

181 << ") as the emergency spill slot.\n");

182 }

183}

184

192 bool IsLA64 = STI.is64Bit();

193

196

197

198

200

201

203 return;

204

205 determineFrameLayout(MF);

206

207

209 uint64_t RealStackSize = StackSize;

210

211

213 return;

214

216

217 if (FirstSPAdjustAmount)

218 StackSize = FirstSPAdjustAmount;

219

220

222

223 unsigned CFIIndex =

228

230

231

232

233

234

235 std::advance(MBBI, CSI.size());

236

237

238

239 for (const auto &Entry : CSI) {

242 nullptr, RI->getDwarfRegNum(Entry.getReg(), true), Offset));

246 }

247

248

251 StackSize - LoongArchFI->getVarArgsSaveSize(),

253

254

257 LoongArchFI->getVarArgsSaveSize()));

261 }

262

263

264 if (FirstSPAdjustAmount) {

265 uint64_t SecondSPAdjustAmount = RealStackSize - FirstSPAdjustAmount;

266 assert(SecondSPAdjustAmount > 0 &&

267 "SecondSPAdjustAmount should be greater than zero");

270

271 if ( hasFP (MF)) {

272

273

274

280 }

281 }

282

284

285 if (RI->hasStackRealignment(MF)) {

287 assert(Align > 0 && "The stack realignment size is invalid!");

289 TII->get(IsLA64 ? LoongArch::BSTRINS_D : LoongArch::BSTRINS_W),

292 .addReg(LoongArch::R0)

296

297

298

300

304 .addReg(LoongArch::R0)

306 }

307 }

308 }

309}

310

317

318

320 return;

323

325

326 auto LastFrameDestroy = MBBI;

327 if (!CSI.empty())

328 LastFrameDestroy = std::prev(MBBI, CSI.size());

329

330

332

333

335 assert(hasFP(MF) && "frame pointer should not have been eliminated");

336 adjustReg(MBB, LastFrameDestroy, DL, SPReg, LoongArch::R22,

337 -StackSize + LoongArchFI->getVarArgsSaveSize(),

339 }

340

342 if (FirstSPAdjustAmount) {

343 uint64_t SecondSPAdjustAmount = StackSize - FirstSPAdjustAmount;

344 assert(SecondSPAdjustAmount > 0 &&

345 "SecondSPAdjustAmount should be greater than zero");

346

347 adjustReg(MBB, LastFrameDestroy, DL, SPReg, SPReg, SecondSPAdjustAmount,

349 StackSize = FirstSPAdjustAmount;

350 }

351

352

354}

355

356

357

358

359

360

361

362

363

368

369

370

372

373

374

375

376

378 }

379 return 0;

380}

381

386

387

389 SavedRegs.set(LoongArch::R1);

390 SavedRegs.set(LoongArch::R22);

391 }

392

395}

396

397

398

399

404

405

412

414

415

416

417

418

419 int64_t Amount = MI->getOperand(0).getImm();

420

421 if (Amount != 0) {

422

424

425 if (MI->getOpcode() == LoongArch::ADJCALLSTACKDOWN)

426 Amount = -Amount;

427

429 }

430 }

431

432 return MBB.erase(MI);

433}

434

439 return true;

440

443

444

445 for (auto &CS : CSI) {

447

448

449 bool IsKill =

450 !(Reg == LoongArch::R1 && MF->getFrameInfo().isReturnAddressTaken());

452 TII.storeRegToStackSlot(MBB, MI, Reg, IsKill, CS.getFrameIdx(), RC,

454 }

455

456 return true;

457}

458

466

467

468

469

471 int MinCSFI = 0;

472 int MaxCSFI = -1;

476

477 if (CSI.size()) {

478 MinCSFI = CSI[0].getFrameIdx();

479 MaxCSFI = CSI[CSI.size() - 1].getFrameIdx();

480 }

481

482 if (FI >= MinCSFI && FI <= MaxCSFI) {

483 FrameReg = LoongArch::R3;

484 if (FirstSPAdjustAmount)

486 else

489

490

491

494 } else {

498 else

500 }

501

503}

504

507

509 return false;

510

511 return true;

512}

unsigned const MachineRegisterInfo * MRI

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

const TargetInstrInfo & TII

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

MachineBasicBlock MachineBasicBlock::iterator MBBI

static uint64_t estimateFunctionSizeInBytes(const LoongArchInstrInfo *TII, const MachineFunction &MF)

Definition LoongArchFrameLowering.cpp:122

static bool needScavSlotForCFR(MachineFunction &MF)

Definition LoongArchFrameLowering.cpp:131

Promote Memory to Register

static constexpr MCPhysReg FPReg

static constexpr MCPhysReg SPReg

This file declares the machine register scavenger class.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

bool empty() const

empty - Check if the array is empty.

CallingConv::ID getCallingConv() const

getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...

bool hasOptNone() const

Do not optimize this function (-O0).

StackOffset getFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg) const override

getFrameIndexReference - This method should return the base register and offset used to reference a f...

Definition LoongArchFrameLowering.cpp:459

uint64_t getFirstSPAdjustAmount(const MachineFunction &MF) const

Definition LoongArchFrameLowering.cpp:364

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

Definition LoongArchFrameLowering.cpp:311

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

This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy p...

Definition LoongArchFrameLowering.cpp:407

bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, ArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override

spillCalleeSavedRegisters - Issues instruction(s) to spill all callee saved registers and returns tru...

Definition LoongArchFrameLowering.cpp:435

void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS) const override

This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...

Definition LoongArchFrameLowering.cpp:382

void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS) const override

processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...

Definition LoongArchFrameLowering.cpp:141

bool enableShrinkWrapping(const MachineFunction &MF) const override

Returns true if the target will correctly handle shrink wrapping.

Definition LoongArchFrameLowering.cpp:505

bool hasFPImpl(const MachineFunction &MF) const override

Definition LoongArchFrameLowering.cpp:34

bool hasReservedCallFrame(const MachineFunction &MF) const override

hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required,...

Definition LoongArchFrameLowering.cpp:400

bool hasBP(const MachineFunction &MF) const

Definition LoongArchFrameLowering.cpp:43

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

emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.

Definition LoongArchFrameLowering.cpp:185

LoongArchMachineFunctionInfo - This class is derived from MachineFunctionInfo and contains private Lo...

int getBranchRelaxationSpillFrameIndex()

void setBranchRelaxationSpillFrameIndex(int Index)

const LoongArchInstrInfo * getInstrInfo() const override

static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc={})

.cfi_def_cfa defines a rule for computing CFA as: take address from Register and add Offset to it.

static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc={})

.cfi_offset Previous value of Register is saved at offset Offset from CFA.

static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int64_t Offset, SMLoc Loc={})

.cfi_def_cfa_offset modifies a rule for computing CFA.

const MCInstrDesc & get(unsigned Opcode) const

Return the machine instruction descriptor that corresponds to the specified instruction opcode.

Wrapper class representing physical registers. Should be passed by value.

const MachineFunction * getParent() const

Return the MachineFunction containing this basic block.

MachineInstrBundleIterator< MachineInstr > iterator

The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.

bool hasVarSizedObjects() const

This method may be called any time after instruction selection is complete to determine if the stack ...

uint64_t getStackSize() const

Return the number of bytes that must be allocated to hold all of the fixed size frame objects.

bool adjustsStack() const

Return true if this function adjusts the stack – e.g., when calling another function.

bool isFrameAddressTaken() const

This method may be called any time after instruction selection is complete to determine if there is a...

Align getMaxAlign() const

Return the alignment in bytes that this function must be aligned to, which is greater than the defaul...

int64_t getOffsetAdjustment() const

Return the correction for frame offsets.

const std::vector< CalleeSavedInfo > & getCalleeSavedInfo() const

Returns a reference to call saved info vector for the current function.

int64_t getObjectOffset(int ObjectIdx) const

Return the assigned stack offset of the specified object from the incoming stack pointer.

void setStackSize(uint64_t Size)

Set the size of the stack.

bool isFixedObjectIndex(int ObjectIdx) const

Returns true if the specified index corresponds to a fixed stack object.

unsigned addFrameInst(const MCCFIInstruction &Inst)

const TargetSubtargetInfo & getSubtarget() const

getSubtarget - Return the subtarget for which this machine code is being compiled.

MachineFrameInfo & getFrameInfo()

getFrameInfo - Return the frame info object for the current function.

MachineRegisterInfo & getRegInfo()

getRegInfo - Return information about the registers currently in use.

Function & getFunction()

Return the LLVM function that this machine code represents.

Ty * getInfo()

getInfo - Keep track of various per-function pieces of information for backends that would like to do...

const TargetMachine & getTarget() const

getTarget - Return the target machine this machine code is compiled with

const MachineInstrBuilder & addCFIIndex(unsigned CFIIndex) const

const MachineInstrBuilder & setMIFlag(MachineInstr::MIFlag Flag) const

const MachineInstrBuilder & addImm(int64_t Val) const

Add a new immediate operand.

const MachineInstrBuilder & addReg(Register RegNo, unsigned flags=0, unsigned SubReg=0) const

Add a new virtual register operand.

Wrapper class representing virtual and physical registers.

StackOffset holds a fixed and a scalable offset in bytes.

int64_t getFixed() const

Returns the fixed component of the stack.

bool hasFP(const MachineFunction &MF) const

hasFP - Return true if the specified function should have a dedicated frame pointer register.

virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const

This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...

int getOffsetOfLocalArea() const

getOffsetOfLocalArea - This method returns the offset of the local area from the stack pointer on ent...

Align getStackAlign() const

getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...

int alignSPAdjust(int SPAdj) const

alignSPAdjust - This method aligns the stack adjustment to the correct alignment.

TargetInstrInfo - Interface to description of machine instruction set.

LLVM_ABI bool DisableFramePointerElim(const MachineFunction &MF) const

DisableFramePointerElim - This returns true if frame pointer elimination optimization should be disab...

TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...

bool hasStackRealignment(const MachineFunction &MF) const

True if stack realignment is required and still possible.

virtual Register getFrameRegister(const MachineFunction &MF) const =0

Debug information queries.

virtual const TargetInstrInfo * getInstrInfo() const

virtual const TargetRegisterInfo * getRegisterInfo() const =0

Return the target's register information.

@ GHC

Used by the Glasgow Haskell Compiler (GHC).

@ Kill

The last use of a register.

This is an optimization pass for GlobalISel generic memory operations.

MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)

Builder interface. Specify how to create the initial instruction itself.

constexpr bool isInt(int64_t x)

Checks if an integer fits into the given bit width.

LLVM_ABI raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

unsigned Log2(Align A)

Returns the log2 of the alignment.

This struct is a compact representation of a valid (non-zero power of two) alignment.

constexpr uint64_t value() const

This is a hole in the type system and should not be abused.