LLVM  13.0.0git
AVRFrameLowering.cpp
Go to the documentation of this file.
1 //===-- AVRFrameLowering.cpp - AVR Frame Information ----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains the AVR implementation of TargetFrameLowering class.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "AVRFrameLowering.h"
14 
15 #include "AVR.h"
16 #include "AVRInstrInfo.h"
17 #include "AVRMachineFunctionInfo.h"
18 #include "AVRTargetMachine.h"
20 
26 #include "llvm/IR/Function.h"
27 
28 #include <vector>
29 
30 namespace llvm {
31 
33  : TargetFrameLowering(TargetFrameLowering::StackGrowsDown, Align(1), -2) {}
34 
36  const MachineFunction &MF) const {
37  // Always simplify call frame pseudo instructions, even when
38  // hasReservedCallFrame is false.
39  return true;
40 }
41 
43  // Reserve call frame memory in function prologue under the following
44  // conditions:
45  // - Y pointer is reserved to be the frame pointer.
46  // - The function does not contain variable sized objects.
47 
48  const MachineFrameInfo &MFI = MF.getFrameInfo();
49  return hasFP(MF) && !MFI.hasVarSizedObjects();
50 }
51 
53  MachineBasicBlock &MBB) const {
55  DebugLoc DL = (MBBI != MBB.end()) ? MBBI->getDebugLoc() : DebugLoc();
56  const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
57  const AVRInstrInfo &TII = *STI.getInstrInfo();
59  bool HasFP = hasFP(MF);
60 
61  // Interrupt handlers re-enable interrupts in function entry.
62  if (AFI->isInterruptHandler()) {
63  BuildMI(MBB, MBBI, DL, TII.get(AVR::BSETs))
64  .addImm(0x07)
66  }
67 
68  // Emit special prologue code to save R1, R0 and SREG in interrupt/signal
69  // handlers before saving any other registers.
70  if (AFI->isInterruptOrSignalHandler()) {
71  BuildMI(MBB, MBBI, DL, TII.get(AVR::PUSHWRr))
72  .addReg(AVR::R1R0, RegState::Kill)
74 
75  BuildMI(MBB, MBBI, DL, TII.get(AVR::INRdA), AVR::R0)
76  .addImm(0x3f)
78  BuildMI(MBB, MBBI, DL, TII.get(AVR::PUSHRr))
79  .addReg(AVR::R0, RegState::Kill)
81  BuildMI(MBB, MBBI, DL, TII.get(AVR::EORRdRr))
82  .addReg(AVR::R0, RegState::Define)
83  .addReg(AVR::R0, RegState::Kill)
84  .addReg(AVR::R0, RegState::Kill)
86  }
87 
88  // Early exit if the frame pointer is not needed in this function.
89  if (!HasFP) {
90  return;
91  }
92 
93  const MachineFrameInfo &MFI = MF.getFrameInfo();
94  unsigned FrameSize = MFI.getStackSize() - AFI->getCalleeSavedFrameSize();
95 
96  // Skip the callee-saved push instructions.
97  while (
98  (MBBI != MBB.end()) && MBBI->getFlag(MachineInstr::FrameSetup) &&
99  (MBBI->getOpcode() == AVR::PUSHRr || MBBI->getOpcode() == AVR::PUSHWRr)) {
100  ++MBBI;
101  }
102 
103  // Update Y with the new base value.
104  BuildMI(MBB, MBBI, DL, TII.get(AVR::SPREAD), AVR::R29R28)
105  .addReg(AVR::SP)
107 
108  // Mark the FramePtr as live-in in every block except the entry.
109  for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
110  I != E; ++I) {
111  I->addLiveIn(AVR::R29R28);
112  }
113 
114  if (!FrameSize) {
115  return;
116  }
117 
118  // Reserve the necessary frame memory by doing FP -= <size>.
119  unsigned Opcode = (isUInt<6>(FrameSize)) ? AVR::SBIWRdK : AVR::SUBIWRdK;
120 
121  MachineInstr *MI = BuildMI(MBB, MBBI, DL, TII.get(Opcode), AVR::R29R28)
122  .addReg(AVR::R29R28, RegState::Kill)
123  .addImm(FrameSize)
125  // The SREG implicit def is dead.
126  MI->getOperand(3).setIsDead();
127 
128  // Write back R29R28 to SP and temporarily disable interrupts.
129  BuildMI(MBB, MBBI, DL, TII.get(AVR::SPWRITE), AVR::SP)
130  .addReg(AVR::R29R28)
132 }
133 
136 
138 
139  DebugLoc DL = MBBI->getDebugLoc();
140  const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
141  const AVRInstrInfo &TII = *STI.getInstrInfo();
142 
143  // Emit special epilogue code to restore R1, R0 and SREG in interrupt/signal
144  // handlers at the very end of the function, just before reti.
145  if (AFI->isInterruptOrSignalHandler()) {
146  BuildMI(MBB, MBBI, DL, TII.get(AVR::POPRd), AVR::R0);
147  BuildMI(MBB, MBBI, DL, TII.get(AVR::OUTARr))
148  .addImm(0x3f)
149  .addReg(AVR::R0, RegState::Kill);
150  BuildMI(MBB, MBBI, DL, TII.get(AVR::POPWRd), AVR::R1R0);
151  }
152 }
153 
155  MachineBasicBlock &MBB) const {
157 
158  // Early exit if the frame pointer is not needed in this function except for
159  // signal/interrupt handlers where special code generation is required.
160  if (!hasFP(MF) && !AFI->isInterruptOrSignalHandler()) {
161  return;
162  }
163 
164  MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
165  assert(MBBI->getDesc().isReturn() &&
166  "Can only insert epilog into returning blocks");
167 
168  DebugLoc DL = MBBI->getDebugLoc();
169  const MachineFrameInfo &MFI = MF.getFrameInfo();
170  unsigned FrameSize = MFI.getStackSize() - AFI->getCalleeSavedFrameSize();
171  const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
172  const AVRInstrInfo &TII = *STI.getInstrInfo();
173 
174  // Early exit if there is no need to restore the frame pointer.
175  if (!FrameSize) {
177  return;
178  }
179 
180  // Skip the callee-saved pop instructions.
181  while (MBBI != MBB.begin()) {
182  MachineBasicBlock::iterator PI = std::prev(MBBI);
183  int Opc = PI->getOpcode();
184 
185  if (Opc != AVR::POPRd && Opc != AVR::POPWRd && !PI->isTerminator()) {
186  break;
187  }
188 
189  --MBBI;
190  }
191 
192  unsigned Opcode;
193 
194  // Select the optimal opcode depending on how big it is.
195  if (isUInt<6>(FrameSize)) {
196  Opcode = AVR::ADIWRdK;
197  } else {
198  Opcode = AVR::SUBIWRdK;
199  FrameSize = -FrameSize;
200  }
201 
202  // Restore the frame pointer by doing FP += <size>.
203  MachineInstr *MI = BuildMI(MBB, MBBI, DL, TII.get(Opcode), AVR::R29R28)
204  .addReg(AVR::R29R28, RegState::Kill)
205  .addImm(FrameSize);
206  // The SREG implicit def is dead.
207  MI->getOperand(3).setIsDead();
208 
209  // Write back R29R28 to SP and temporarily disable interrupts.
210  BuildMI(MBB, MBBI, DL, TII.get(AVR::SPWRITE), AVR::SP)
211  .addReg(AVR::R29R28, RegState::Kill);
212 
214 }
215 
216 // Return true if the specified function should have a dedicated frame
217 // pointer register. This is true if the function meets any of the following
218 // conditions:
219 // - a register has been spilled
220 // - has allocas
221 // - input arguments are passed using the stack
222 //
223 // Notice that strictly this is not a frame pointer because it contains SP after
224 // frame allocation instead of having the original SP in function entry.
226  const AVRMachineFunctionInfo *FuncInfo = MF.getInfo<AVRMachineFunctionInfo>();
227 
228  return (FuncInfo->getHasSpills() || FuncInfo->getHasAllocas() ||
229  FuncInfo->getHasStackArgs());
230 }
231 
235  if (CSI.empty()) {
236  return false;
237  }
238 
239  unsigned CalleeFrameSize = 0;
240  DebugLoc DL = MBB.findDebugLoc(MI);
241  MachineFunction &MF = *MBB.getParent();
242  const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
243  const TargetInstrInfo &TII = *STI.getInstrInfo();
245 
246  for (unsigned i = CSI.size(); i != 0; --i) {
247  unsigned Reg = CSI[i - 1].getReg();
248  bool IsNotLiveIn = !MBB.isLiveIn(Reg);
249 
250  assert(TRI->getRegSizeInBits(*TRI->getMinimalPhysRegClass(Reg)) == 8 &&
251  "Invalid register size");
252 
253  // Add the callee-saved register as live-in only if it is not already a
254  // live-in register, this usually happens with arguments that are passed
255  // through callee-saved registers.
256  if (IsNotLiveIn) {
257  MBB.addLiveIn(Reg);
258  }
259 
260  // Do not kill the register when it is an input argument.
261  BuildMI(MBB, MI, DL, TII.get(AVR::PUSHRr))
262  .addReg(Reg, getKillRegState(IsNotLiveIn))
264  ++CalleeFrameSize;
265  }
266 
267  AVRFI->setCalleeSavedFrameSize(CalleeFrameSize);
268 
269  return true;
270 }
271 
275  if (CSI.empty()) {
276  return false;
277  }
278 
279  DebugLoc DL = MBB.findDebugLoc(MI);
280  const MachineFunction &MF = *MBB.getParent();
281  const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
282  const TargetInstrInfo &TII = *STI.getInstrInfo();
283 
284  for (const CalleeSavedInfo &CCSI : CSI) {
285  unsigned Reg = CCSI.getReg();
286 
287  assert(TRI->getRegSizeInBits(*TRI->getMinimalPhysRegClass(Reg)) == 8 &&
288  "Invalid register size");
289 
290  BuildMI(MBB, MI, DL, TII.get(AVR::POPRd), Reg);
291  }
292 
293  return true;
294 }
295 
296 /// Replace pseudo store instructions that pass arguments through the stack with
297 /// real instructions.
300  const TargetInstrInfo &TII, Register FP) {
301  // Iterate through the BB until we hit a call instruction or we reach the end.
302  for (auto I = MI, E = MBB.end(); I != E && !I->isCall();) {
303  MachineBasicBlock::iterator NextMI = std::next(I);
304  MachineInstr &MI = *I;
305  unsigned Opcode = I->getOpcode();
306 
307  // Only care of pseudo store instructions where SP is the base pointer.
308  if (Opcode != AVR::STDSPQRr && Opcode != AVR::STDWSPQRr) {
309  I = NextMI;
310  continue;
311  }
312 
313  assert(MI.getOperand(0).getReg() == AVR::SP &&
314  "Invalid register, should be SP!");
315 
316  // Replace this instruction with a regular store. Use Y as the base
317  // pointer since it is guaranteed to contain a copy of SP.
318  unsigned STOpc =
319  (Opcode == AVR::STDWSPQRr) ? AVR::STDWPtrQRr : AVR::STDPtrQRr;
320 
321  MI.setDesc(TII.get(STOpc));
322  MI.getOperand(0).setReg(FP);
323 
324  I = NextMI;
325  }
326 }
327 
331  const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
332  const AVRInstrInfo &TII = *STI.getInstrInfo();
333 
334  // There is nothing to insert when the call frame memory is allocated during
335  // function entry. Delete the call frame pseudo and replace all pseudo stores
336  // with real store instructions.
337  if (hasReservedCallFrame(MF)) {
338  fixStackStores(MBB, MI, TII, AVR::R29R28);
339  return MBB.erase(MI);
340  }
341 
342  DebugLoc DL = MI->getDebugLoc();
343  unsigned int Opcode = MI->getOpcode();
344  int Amount = TII.getFrameSize(*MI);
345 
346  // ADJCALLSTACKUP and ADJCALLSTACKDOWN are converted to adiw/subi
347  // instructions to read and write the stack pointer in I/O space.
348  if (Amount != 0) {
349  assert(getStackAlign() == Align(1) && "Unsupported stack alignment");
350 
351  if (Opcode == TII.getCallFrameSetupOpcode()) {
352  // Update the stack pointer.
353  // In many cases this can be done far more efficiently by pushing the
354  // relevant values directly to the stack. However, doing that correctly
355  // (in the right order, possibly skipping some empty space for undef
356  // values, etc) is tricky and thus left to be optimized in the future.
357  BuildMI(MBB, MI, DL, TII.get(AVR::SPREAD), AVR::R31R30).addReg(AVR::SP);
358 
359  MachineInstr *New = BuildMI(MBB, MI, DL, TII.get(AVR::SUBIWRdK), AVR::R31R30)
360  .addReg(AVR::R31R30, RegState::Kill)
361  .addImm(Amount);
362  New->getOperand(3).setIsDead();
363 
364  BuildMI(MBB, MI, DL, TII.get(AVR::SPWRITE), AVR::SP)
365  .addReg(AVR::R31R30);
366 
367  // Make sure the remaining stack stores are converted to real store
368  // instructions.
369  fixStackStores(MBB, MI, TII, AVR::R31R30);
370  } else {
371  assert(Opcode == TII.getCallFrameDestroyOpcode());
372 
373  // Note that small stack changes could be implemented more efficiently
374  // with a few pop instructions instead of the 8-9 instructions now
375  // required.
376 
377  // Select the best opcode to adjust SP based on the offset size.
378  unsigned addOpcode;
379  if (isUInt<6>(Amount)) {
380  addOpcode = AVR::ADIWRdK;
381  } else {
382  addOpcode = AVR::SUBIWRdK;
383  Amount = -Amount;
384  }
385 
386  // Build the instruction sequence.
387  BuildMI(MBB, MI, DL, TII.get(AVR::SPREAD), AVR::R31R30).addReg(AVR::SP);
388 
389  MachineInstr *New = BuildMI(MBB, MI, DL, TII.get(addOpcode), AVR::R31R30)
390  .addReg(AVR::R31R30, RegState::Kill)
391  .addImm(Amount);
392  New->getOperand(3).setIsDead();
393 
394  BuildMI(MBB, MI, DL, TII.get(AVR::SPWRITE), AVR::SP)
395  .addReg(AVR::R31R30, RegState::Kill);
396  }
397  }
398 
399  return MBB.erase(MI);
400 }
401 
403  BitVector &SavedRegs,
404  RegScavenger *RS) const {
406 
407  // If we have a frame pointer, the Y register needs to be saved as well.
408  if (hasFP(MF)) {
409  SavedRegs.set(AVR::R29);
410  SavedRegs.set(AVR::R28);
411  }
412 }
413 /// The frame analyzer pass.
414 ///
415 /// Scans the function for allocas and used arguments
416 /// that are passed through the stack.
418  static char ID;
420 
422  const MachineFrameInfo &MFI = MF.getFrameInfo();
424 
425  // If there are no fixed frame indexes during this stage it means there
426  // are allocas present in the function.
427  if (MFI.getNumObjects() != MFI.getNumFixedObjects()) {
428  // Check for the type of allocas present in the function. We only care
429  // about fixed size allocas so do not give false positives if only
430  // variable sized allocas are present.
431  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
432  // Variable sized objects have size 0.
433  if (MFI.getObjectSize(i)) {
434  FuncInfo->setHasAllocas(true);
435  break;
436  }
437  }
438  }
439 
440  // If there are fixed frame indexes present, scan the function to see if
441  // they are really being used.
442  if (MFI.getNumFixedObjects() == 0) {
443  return false;
444  }
445 
446  // Ok fixed frame indexes present, now scan the function to see if they
447  // are really being used, otherwise we can ignore them.
448  for (const MachineBasicBlock &BB : MF) {
449  for (const MachineInstr &MI : BB) {
450  int Opcode = MI.getOpcode();
451 
452  if ((Opcode != AVR::LDDRdPtrQ) && (Opcode != AVR::LDDWRdPtrQ) &&
453  (Opcode != AVR::STDPtrQRr) && (Opcode != AVR::STDWPtrQRr)) {
454  continue;
455  }
456 
457  for (const MachineOperand &MO : MI.operands()) {
458  if (!MO.isFI()) {
459  continue;
460  }
461 
462  if (MFI.isFixedObjectIndex(MO.getIndex())) {
463  FuncInfo->setHasStackArgs(true);
464  return false;
465  }
466  }
467  }
468  }
469 
470  return false;
471  }
472 
473  StringRef getPassName() const override { return "AVR Frame Analyzer"; }
474 };
475 
476 char AVRFrameAnalyzer::ID = 0;
477 
478 /// Creates instance of the frame analyzer pass.
480 
481 /// Create the Dynalloca Stack Pointer Save/Restore pass.
482 /// Insert a copy of SP before allocating the dynamic stack memory and restore
483 /// it in function exit to restore the original SP state. This avoids the need
484 /// of reserving a register pair for a frame pointer.
486  static char ID;
488 
490  // Early exit when there are no variable sized objects in the function.
491  if (!MF.getFrameInfo().hasVarSizedObjects()) {
492  return false;
493  }
494 
495  const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
496  const TargetInstrInfo &TII = *STI.getInstrInfo();
497  MachineBasicBlock &EntryMBB = MF.front();
499  DebugLoc DL = EntryMBB.findDebugLoc(MBBI);
500 
501  Register SPCopy =
502  MF.getRegInfo().createVirtualRegister(&AVR::DREGSRegClass);
503 
504  // Create a copy of SP in function entry before any dynallocas are
505  // inserted.
506  BuildMI(EntryMBB, MBBI, DL, TII.get(AVR::COPY), SPCopy).addReg(AVR::SP);
507 
508  // Restore SP in all exit basic blocks.
509  for (MachineBasicBlock &MBB : MF) {
510  // If last instruction is a return instruction, add a restore copy.
511  if (!MBB.empty() && MBB.back().isReturn()) {
512  MBBI = MBB.getLastNonDebugInstr();
513  DL = MBBI->getDebugLoc();
514  BuildMI(MBB, MBBI, DL, TII.get(AVR::COPY), AVR::SP)
515  .addReg(SPCopy, RegState::Kill);
516  }
517  }
518 
519  return true;
520  }
521 
522  StringRef getPassName() const override {
523  return "AVR dynalloca stack pointer save/restore";
524  }
525 };
526 
527 char AVRDynAllocaSR::ID = 0;
528 
529 /// createAVRDynAllocaSRPass - returns an instance of the dynalloca stack
530 /// pointer save/restore pass.
532 
533 } // end of namespace llvm
534 
i
i
Definition: README.txt:29
CmpMode::FP
@ FP
llvm::MachineFrameInfo::hasVarSizedObjects
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
Definition: MachineFrameInfo.h:351
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:100
llvm::MachineInstrBuilder::addImm
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
Definition: MachineInstrBuilder.h:131
llvm
Definition: AllocatorList.h:23
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
llvm::AVRFrameLowering::hasReservedCallFrame
bool hasReservedCallFrame(const MachineFunction &MF) const override
hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required,...
Definition: AVRFrameLowering.cpp:42
llvm::TargetFrameLowering
Information about stack frame layout on the target.
Definition: TargetFrameLowering.h:42
llvm::MachineRegisterInfo::createVirtualRegister
Register createVirtualRegister(const TargetRegisterClass *RegClass, StringRef Name="")
createVirtualRegister - Create and return a new virtual register in the function with the specified r...
Definition: MachineRegisterInfo.cpp:158
llvm::MachineFrameInfo::getNumFixedObjects
unsigned getNumFixedObjects() const
Return the number of fixed objects.
Definition: MachineFrameInfo.h:394
llvm::AVRMachineFunctionInfo::setHasStackArgs
void setHasStackArgs(bool B)
Definition: AVRMachineFunctionInfo.h:69
llvm::AVRFrameLowering::determineCalleeSaves
void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const override
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
Definition: AVRFrameLowering.cpp:402
llvm::BitVector::set
BitVector & set()
Definition: BitVector.h:343
llvm::AVRFrameLowering::canSimplifyCallFramePseudos
bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override
canSimplifyCallFramePseudos - When possible, it's best to simplify the call frame pseudo ops before d...
Definition: AVRFrameLowering.cpp:35
llvm::MachineFunction::end
iterator end()
Definition: MachineFunction.h:742
llvm::MachineFunctionPass
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Definition: MachineFunctionPass.h:30
llvm::MachineBasicBlock::findDebugLoc
DebugLoc findDebugLoc(instr_iterator MBBI)
Find the next valid DebugLoc starting at MBBI, skipping any DBG_VALUE and DBG_LABEL instructions.
Definition: MachineBasicBlock.cpp:1398
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:231
llvm::AVRFrameLowering::emitEpilogue
void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override
Definition: AVRFrameLowering.cpp:154
llvm::MachineFrameInfo::getObjectIndexEnd
int getObjectIndexEnd() const
Return one past the maximum frame object index.
Definition: MachineFrameInfo.h:391
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
llvm::RegState::Kill
@ Kill
The last use of a register.
Definition: MachineInstrBuilder.h:48
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:158
MachineRegisterInfo.h
llvm::AVRMachineFunctionInfo::getHasStackArgs
bool getHasStackArgs() const
Definition: AVRMachineFunctionInfo.h:68
llvm::AVRMachineFunctionInfo::setCalleeSavedFrameSize
void setCalleeSavedFrameSize(unsigned Bytes)
Definition: AVRMachineFunctionInfo.h:78
llvm::MachineFunction::front
const MachineBasicBlock & front() const
Definition: MachineFunction.h:752
llvm::MachineFunction::getRegInfo
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Definition: MachineFunction.h:568
llvm::TargetInstrInfo
TargetInstrInfo - Interface to description of machine instruction set.
Definition: TargetInstrInfo.h:97
llvm::MutableArrayRef
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:305
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::MachineFunction::getInfo
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
Definition: MachineFunction.h:656
llvm::TargetFrameLowering::getStackAlign
Align getStackAlign() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
Definition: TargetFrameLowering.h:99
llvm::AVRSubtarget
A specific AVR target MCU.
Definition: AVRSubtarget.h:31
llvm::RegState::Define
@ Define
Register definition.
Definition: MachineInstrBuilder.h:44
TII
const HexagonInstrInfo * TII
Definition: HexagonCopyToCombine.cpp:129
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
llvm::MachineInstr::FrameSetup
@ FrameSetup
Definition: MachineInstr.h:82
llvm::AVRSubtarget::getInstrInfo
const AVRInstrInfo * getInstrInfo() const override
Definition: AVRSubtarget.h:41
llvm::MachineFunction::begin
iterator begin()
Definition: MachineFunction.h:740
llvm::MachineFrameInfo::getStackSize
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
Definition: MachineFrameInfo.h:551
llvm::AVRFrameLowering::hasFP
bool hasFP(const MachineFunction &MF) const override
hasFP - Return true if the specified function should have a dedicated frame pointer register.
Definition: AVRFrameLowering.cpp:225
llvm::AVRMachineFunctionInfo::getCalleeSavedFrameSize
unsigned getCalleeSavedFrameSize() const
Definition: AVRMachineFunctionInfo.h:77
llvm::BitVector
Definition: BitVector.h:74
Align
uint64_t Align
Definition: ELFObjHandler.cpp:83
llvm::MachineFrameInfo::isFixedObjectIndex
bool isFixedObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a fixed stack object.
Definition: MachineFrameInfo.h:654
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::AVRFrameAnalyzer::ID
static char ID
Definition: AVRFrameLowering.cpp:418
llvm::AVRFrameLowering::eliminateCallFramePseudoInstr
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: AVRFrameLowering.cpp:328
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::MachineFunction::getSubtarget
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Definition: MachineFunction.h:558
llvm::MachineInstrBuilder::setMIFlag
const MachineInstrBuilder & setMIFlag(MachineInstr::MIFlag Flag) const
Definition: MachineInstrBuilder.h:278
llvm::AVRFrameAnalyzer
The frame analyzer pass.
Definition: AVRFrameLowering.cpp:417
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::MachineFrameInfo::getObjectSize
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
Definition: MachineFrameInfo.h:451
AVRFrameLowering.h
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::createAVRDynAllocaSRPass
FunctionPass * createAVRDynAllocaSRPass()
createAVRDynAllocaSRPass - returns an instance of the dynalloca stack pointer save/restore pass.
Definition: AVRFrameLowering.cpp:531
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::RegScavenger
Definition: RegisterScavenging.h:34
llvm::AVRMachineFunctionInfo::isInterruptHandler
bool isInterruptHandler() const
Definition: AVRMachineFunctionInfo.h:74
llvm::MachineBasicBlock::getLastNonDebugInstr
iterator getLastNonDebugInstr(bool SkipPseudoOp=true)
Returns an iterator to the last non-debug instruction in the basic block, or end().
Definition: MachineBasicBlock.cpp:266
MachineFunctionPass.h
AVRTargetMachine.h
llvm::AVRMachineFunctionInfo::setHasAllocas
void setHasAllocas(bool B)
Definition: AVRMachineFunctionInfo.h:66
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::fixStackStores
static void fixStackStores(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const TargetInstrInfo &TII, Register FP)
Replace pseudo store instructions that pass arguments through the stack with real instructions.
Definition: AVRFrameLowering.cpp:298
llvm::restoreStatusRegister
static void restoreStatusRegister(MachineFunction &MF, MachineBasicBlock &MBB)
Definition: AVRFrameLowering.cpp:134
llvm::MachineFunction::getFrameInfo
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
Definition: MachineFunction.h:574
AVRMCTargetDesc.h
llvm::MachineInstrBuilder::addReg
const MachineInstrBuilder & addReg(Register RegNo, unsigned flags=0, unsigned SubReg=0) const
Add a new virtual register operand.
Definition: MachineInstrBuilder.h:97
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
MBBI
MachineBasicBlock MachineBasicBlock::iterator MBBI
Definition: AArch64SLSHardening.cpp:75
llvm::AVRMachineFunctionInfo::getHasSpills
bool getHasSpills() const
Definition: AVRMachineFunctionInfo.h:62
AVRMachineFunctionInfo.h
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::AVRFrameLowering::emitPrologue
void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
Definition: AVRFrameLowering.cpp:52
llvm::AVRMachineFunctionInfo::getHasAllocas
bool getHasAllocas() const
Definition: AVRMachineFunctionInfo.h:65
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::CalleeSavedInfo
The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in t...
Definition: MachineFrameInfo.h:34
llvm::createAVRFrameAnalyzerPass
FunctionPass * createAVRFrameAnalyzerPass()
Creates instance of the frame analyzer pass.
Definition: AVRFrameLowering.cpp:479
llvm::ilist_iterator
Iterator for intrusive lists based on ilist_node.
Definition: ilist_iterator.h:57
MachineFrameInfo.h
Function.h
llvm::AVRDynAllocaSR::getPassName
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
Definition: AVRFrameLowering.cpp:522
llvm::AVRDynAllocaSR::AVRDynAllocaSR
AVRDynAllocaSR()
Definition: AVRFrameLowering.cpp:487
AVR.h
llvm::AVRMachineFunctionInfo::isInterruptOrSignalHandler
bool isInterruptOrSignalHandler() const
Checks if the function is some form of interrupt service routine.
Definition: AVRMachineFunctionInfo.h:72
llvm::MachineFrameInfo::getNumObjects
unsigned getNumObjects() const
Return the number of objects.
Definition: MachineFrameInfo.h:397
llvm::AVRFrameLowering::spillCalleeSavedRegisters
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: AVRFrameLowering.cpp:232
llvm::AVRFrameLowering::AVRFrameLowering
AVRFrameLowering()
Definition: AVRFrameLowering.cpp:32
llvm::getKillRegState
unsigned getKillRegState(bool B)
Definition: MachineInstrBuilder.h:508
llvm::MachineFrameInfo
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Definition: MachineFrameInfo.h:107
llvm::MachineBasicBlock::begin
iterator begin()
Definition: MachineBasicBlock.h:268
MachineInstrBuilder.h
llvm::BuildMI
MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
Definition: MachineInstrBuilder.h:328
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
llvm::AVRInstrInfo
Utilities related to the AVR instruction set.
Definition: AVRInstrInfo.h:64
llvm::AVRDynAllocaSR
Create the Dynalloca Stack Pointer Save/Restore pass.
Definition: AVRFrameLowering.cpp:485
llvm::AVRMachineFunctionInfo
Contains AVR-specific information for each MachineFunction.
Definition: AVRMachineFunctionInfo.h:21
AVRInstrInfo.h
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::TargetFrameLowering::determineCalleeSaves
virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
Definition: TargetFrameLoweringImpl.cpp:78
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
MachineFunction.h
llvm::AVRFrameAnalyzer::runOnMachineFunction
bool runOnMachineFunction(MachineFunction &MF) override
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
Definition: AVRFrameLowering.cpp:421
llvm::MachineInstrBundleIterator< MachineInstr >
llvm::AVRDynAllocaSR::runOnMachineFunction
bool runOnMachineFunction(MachineFunction &MF) override
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
Definition: AVRFrameLowering.cpp:489
llvm::AVRDynAllocaSR::ID
static char ID
Definition: AVRFrameLowering.cpp:486
llvm::AVRFrameAnalyzer::AVRFrameAnalyzer
AVRFrameAnalyzer()
Definition: AVRFrameLowering.cpp:419
llvm::MachineBasicBlock::end
iterator end()
Definition: MachineBasicBlock.h:270
llvm::AVRFrameLowering::restoreCalleeSavedRegisters
bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, MutableArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee saved registers and returns...
Definition: AVRFrameLowering.cpp:272
llvm::AVRFrameAnalyzer::getPassName
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
Definition: AVRFrameLowering.cpp:473