TargetFrameLowering.h Source File (original) (raw)

13#ifndef LLVM_CODEGEN_TARGETFRAMELOWERING_H

14#define LLVM_CODEGEN_TARGETFRAMELOWERING_H

20#include

22namespace llvm {

23 class BitVector;

24 class CalleeSavedInfo;

25 class MachineFunction;

26 class RegScavenger;

28namespace TargetStackID {

36}

46public:

48 StackGrowsUp,

49 StackGrowsDown

55 int64_t Offset;

56 };

63 unsigned Kind;

65 };

66 union {

73 };

75private:

77 Align StackAlignment;

78 Align TransientStackAlignment;

79 int LocalAreaOffset;

80 bool StackRealignable;

81public:

83 Align TransAl = Align(1), bool StackReal = true)

84 : StackDir(D), StackAlignment(StackAl), TransientStackAlignment(TransAl),

85 LocalAreaOffset(LAO), StackRealignable(StackReal) {}

101

102

103

104

106

107

108

110

111

112

113

115 if (SPAdj < 0) {

116 SPAdj = -alignTo(-SPAdj, StackAlignment);

117 } else {

118 SPAdj = alignTo(SPAdj, StackAlignment);

119 }

120 return SPAdj;

121 }

122

123

124

125

126

128

129

130

132 return StackRealignable;

133 }

134

135

136

138 return true;

139 }

140

141

142

143

145

146

147

148

149

150

153

154

155

156

157

158

159

162 std::vector &CSI,

163 unsigned &MinCSFrameIndex,

164 unsigned &MaxCSFrameIndex) const {

166 }

167

168 virtual bool

171 std::vector &CSI) const {

172 return false;

173 }

174

175

176

177

178

179

180

181

182

183

184 virtual const SpillSlot *

186 NumEntries = 0;

187 return nullptr;

188 }

189

190

191

192

194 return false;

195 }

196

197

199 return false;

200 }

201

202

203

204

206 return false;

207 }

208

209

210

212

213

214

219

220

223

224

225

226 virtual void

229

230

231

233

234

235

237

238

241

242

244

245

246

249

250

251

254

255

256

257

258

263 return false;

264 }

265

266

267

268

269

270

271

272 virtual bool

277 return false;

278 }

279

280

281

282

283

284

287 }

288

289

290

291

292

293

295 return hasFP (MF);

296 }

297

298

299

300

301

302

303

304

307 }

308

309

310

311

313

314

315

316

319

320

321

322

323

324

325

329 bool IgnoreSPUpdates) const {

330

332 }

333

334

335

336

338 int FI) const {

339

340

343 }

344

345

346

347

348

350 int FI) const;

351

352

353

356

357

358

359

360

361

362

363

364

365

366

369

370

371

372

373

374

377 }

378

379

380

381

382 virtual void

385

388 }

389

390

391

392

393

394

395

400 llvm_unreachable("Call Frame Pseudo Instructions do not exist on this "

401 "target!");

402 }

403

404

405

406

407

408

409

410

411 virtual void

414 }

415

416

417

418

419

420

421

422

423

425 return true;

426 }

427

428

429

430

431

432

433

434

435

437 return true;

438 }

439

440

443 }

444

446 switch (ID) {

447 default:

448 return false;

451 return true;

452 }

453 }

454

455

456

458

459

461 return true;

462 }

463

464

465

467

468

469

471

472

473

475

476

477

479

480

481

484

485protected:

487};

488

489}

490

491#endif

MachineBasicBlock MachineBasicBlock::iterator MBBI

This file implements the BitVector class.

static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")

unsigned const TargetRegisterInfo * TRI

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

bool hasFnAttribute(Attribute::AttrKind Kind) const

Return true if the function has the attribute.

Function & getFunction()

Return the LLVM function that this machine code represents.

MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...

Wrapper class representing virtual and physical registers.

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

StackOffset holds a fixed and a scalable offset in bytes.

Information about stack frame layout on the target.

virtual void spillFPBP(MachineFunction &MF) const

If frame pointer or base pointer is clobbered by an instruction, we should spill/restore it around th...

unsigned getStackAlignment() const

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

virtual void emitCalleeSavedFrameMovesFullCFA(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI) const

With basic block sections, emit callee saved frame moves for basic blocks that are in a different sec...

bool hasFP(const MachineFunction &MF) const

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

virtual void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const =0

virtual const SpillSlot * getCalleeSavedSpillSlots(unsigned &NumEntries) const

getCalleeSavedSpillSlots - This method returns a pointer to an array of pairs, that contains an entry...

virtual bool hasReservedCallFrame(const MachineFunction &MF) const

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

virtual bool enableStackSlotScavenging(const MachineFunction &MF) const

Returns true if the stack slot holes in the fixed and callee-save stack area should be used when allo...

virtual bool allocateScavengingFrameIndexesNearIncomingSP(const MachineFunction &MF) const

Control the placement of special register scavenging spill slots when allocating a stack frame.

Align getTransientStackAlign() const

getTransientStackAlignment - This method returns the number of bytes to which the stack pointer must ...

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

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

virtual uint64_t getStackThreshold() const

getStackThreshold - Return the maximum stack size

virtual void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS=nullptr) const

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

virtual bool enableCalleeSaveSkip(const MachineFunction &MF) const

Returns true if the target can safely skip saving callee-saved registers for noreturn nounwind functi...

virtual bool enableShrinkWrapping(const MachineFunction &MF) const

Returns true if the target will correctly handle shrink wrapping.

virtual void inlineStackProbe(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const

Replace a StackProbe stub (if any) with the actual probe code inline.

virtual void orderFrameObjects(const MachineFunction &MF, SmallVectorImpl< int > &objectsToAllocate) const

Order the symbols in the local stack frame.

virtual bool isStackIdSafeForLocalArea(unsigned StackId) const

This method returns whether or not it is safe for an object with the given stack id to be bundled int...

virtual void adjustForHiPEPrologue(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const

Adjust the prologue to add Erlang Run-Time System (ERTS) specific code in the assembly prologue to ex...

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

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

virtual Register getInitialCFARegister(const MachineFunction &MF) const

Return initial CFA register value i.e.

virtual bool stackProbeFunctionModifiesSP() const

Does the stack probe function call return with a modified stack pointer?

bool isStackRealignable() const

isStackRealignable - This method returns whether the stack can be realigned.

virtual TargetStackID::Value getStackIDForScalableVectors() const

Returns the StackID that scalable vectors should be associated with.

virtual void getCalleeSaves(const MachineFunction &MF, BitVector &SavedRegs) const

Returns the callee-saved registers as computed by determineCalleeSaves in the BitVector SavedRegs.

int getOffsetOfLocalArea() const

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

virtual DwarfFrameBase getDwarfFrameBase(const MachineFunction &MF) const

Return the frame base information to be encoded in the DWARF subprogram debug info.

virtual bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI, unsigned &MinCSFrameIndex, unsigned &MaxCSFrameIndex) const

assignCalleeSavedSpillSlots - Allows target to override spill slot assignment logic.

TargetFrameLowering(StackDirection D, Align StackAl, int LAO, Align TransAl=Align(1), bool StackReal=true)

virtual bool needsFrameIndexResolution(const MachineFunction &MF) const

virtual bool isSupportedStackID(TargetStackID::Value ID) const

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

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

Align getStackAlign() const

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

virtual StackOffset getNonLocalFrameIndexReference(const MachineFunction &MF, int FI) const

getNonLocalFrameIndexReference - This method returns the offset used to reference a frame index locat...

virtual bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI) const

virtual void processFunctionBeforeFrameIndicesReplaced(MachineFunction &MF, RegScavenger *RS=nullptr) const

processFunctionBeforeFrameIndicesReplaced - This method is called immediately before MO_FrameIndex op...

virtual StackOffset getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI, Register &FrameReg, bool IgnoreSPUpdates) const

Same as getFrameIndexReference, except that the stack pointer (as opposed to the frame pointer) will ...

virtual bool isProfitableForNoCSROpt(const Function &F) const

Check if the no-CSR optimisation is profitable for the given function.

StackDirection getStackGrowthDirection() const

getStackGrowthDirection - Return the direction the stack grows

virtual bool canUseAsEpilogue(const MachineBasicBlock &MBB) const

Check whether or not the given MBB can be used as a epilogue for the target.

virtual void adjustForSegmentedStacks(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const

Adjust the prologue to have the function use segmented stacks.

virtual bool canUseAsPrologue(const MachineBasicBlock &MBB) const

Check whether or not the given MBB can be used as a prologue for the target.

int alignSPAdjust(int SPAdj) const

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

static bool isSafeForNoCSROpt(const Function &F)

Check if given function is safe for not having callee saved registers.

virtual void resetCFIToInitialState(MachineBasicBlock &MBB) const

Emit CFI instructions that recreate the state of the unwind information upon fucntion entry.

virtual bool canSimplifyCallFramePseudos(const MachineFunction &MF) const

canSimplifyCallFramePseudos - When possible, it's best to simplify the call frame pseudo ops before d...

virtual bool hasFPImpl(const MachineFunction &MF) const =0

virtual void emitZeroCallUsedRegs(BitVector RegsToZero, MachineBasicBlock &MBB) const

emitZeroCallUsedRegs - Zeros out call used registers.

virtual bool enableCFIFixup(MachineFunction &MF) const

Returns true if we may need to fix the unwind information for the function.

virtual void emitRemarks(const MachineFunction &MF, MachineOptimizationRemarkEmitter *ORE) const

This method is called at the end of prolog/epilog code insertion, so targets can emit remarks based o...

virtual ~TargetFrameLowering()

virtual StackOffset getFrameIndexReferenceFromSP(const MachineFunction &MF, int FI) const

getFrameIndexReferenceFromSP - This method returns the offset from the stack pointer to the slot of t...

virtual bool targetHandlesStackFrameRounding() const

targetHandlesStackFrameRounding - Returns true if the target is responsible for rounding up the stack...

virtual int getInitialCFAOffset(const MachineFunction &MF) const

Return initial CFA offset value i.e.

virtual unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const

virtual void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const =0

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

virtual bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, MutableArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const

restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee saved registers and returns...

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

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

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

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

This is an optimization pass for GlobalISel generic memory operations.

void report_fatal_error(Error Err, bool gen_crash_diag=true)

Report a serious error, calling any installed error handler.

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

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

uint64_t value() const

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

union llvm::TargetFrameLowering::DwarfFrameBase::@248 Location

enum llvm::TargetFrameLowering::DwarfFrameBase::FrameBaseKind Kind

struct WasmFrameBase WasmLoc