1 //===-- AVRMachineFuctionInfo.h - AVR machine function info -----*- C++ -*-===// 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 declares AVR-specific per-machine-function information. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_AVR_MACHINE_FUNCTION_INFO_H 14 #define LLVM_AVR_MACHINE_FUNCTION_INFO_H 15 16 #include "llvm/CodeGen/MachineFunction.h" 17 18 namespace llvm { 19 20 /// Contains AVR-specific information for each MachineFunction. 21 class AVRMachineFunctionInfo : public MachineFunctionInfo { 22 /// Indicates if a register has been spilled by the register 23 /// allocator. 24 bool HasSpills; 25 26 /// Indicates if there are any fixed size allocas present. 27 /// Note that if there are only variable sized allocas this is set to false. 28 bool HasAllocas; 29 30 /// Indicates if arguments passed using the stack are being 31 /// used inside the function. 32 bool HasStackArgs; 33 34 /// Whether or not the function is an interrupt handler. 35 bool IsInterruptHandler; 36 37 /// Whether or not the function is an non-blocking interrupt handler. 38 bool IsSignalHandler; 39 40 /// Size of the callee-saved register portion of the 41 /// stack frame in bytes. 42 unsigned CalleeSavedFrameSize; 43 44 /// FrameIndex for start of varargs area. 45 int VarArgsFrameIndex; 46 47 public: AVRMachineFunctionInfo(const Function & F,const TargetSubtargetInfo * STI)48 AVRMachineFunctionInfo(const Function &F, const TargetSubtargetInfo *STI) 49 : HasSpills(false), HasAllocas(false), HasStackArgs(false), 50 CalleeSavedFrameSize(0), VarArgsFrameIndex(0) { 51 CallingConv::ID CallConv = F.getCallingConv(); 52 53 this->IsInterruptHandler = 54 CallConv == CallingConv::AVR_INTR || F.hasFnAttribute("interrupt"); 55 this->IsSignalHandler = 56 CallConv == CallingConv::AVR_SIGNAL || F.hasFnAttribute("signal"); 57 } 58 59 MachineFunctionInfo * clone(BumpPtrAllocator & Allocator,MachineFunction & DestMF,const DenseMap<MachineBasicBlock *,MachineBasicBlock * > & Src2DstMBB)60 clone(BumpPtrAllocator &Allocator, MachineFunction &DestMF, 61 const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB) 62 const override { 63 return DestMF.cloneInfo<AVRMachineFunctionInfo>(*this); 64 } 65 getHasSpills()66 bool getHasSpills() const { return HasSpills; } setHasSpills(bool B)67 void setHasSpills(bool B) { HasSpills = B; } 68 getHasAllocas()69 bool getHasAllocas() const { return HasAllocas; } setHasAllocas(bool B)70 void setHasAllocas(bool B) { HasAllocas = B; } 71 getHasStackArgs()72 bool getHasStackArgs() const { return HasStackArgs; } setHasStackArgs(bool B)73 void setHasStackArgs(bool B) { HasStackArgs = B; } 74 75 /// Checks if the function is some form of interrupt service routine. isInterruptOrSignalHandler()76 bool isInterruptOrSignalHandler() const { 77 return isInterruptHandler() || isSignalHandler(); 78 } 79 isInterruptHandler()80 bool isInterruptHandler() const { return IsInterruptHandler; } isSignalHandler()81 bool isSignalHandler() const { return IsSignalHandler; } 82 getCalleeSavedFrameSize()83 unsigned getCalleeSavedFrameSize() const { return CalleeSavedFrameSize; } setCalleeSavedFrameSize(unsigned Bytes)84 void setCalleeSavedFrameSize(unsigned Bytes) { CalleeSavedFrameSize = Bytes; } 85 getVarArgsFrameIndex()86 int getVarArgsFrameIndex() const { return VarArgsFrameIndex; } setVarArgsFrameIndex(int Idx)87 void setVarArgsFrameIndex(int Idx) { VarArgsFrameIndex = Idx; } 88 }; 89 90 } // namespace llvm 91 92 #endif // LLVM_AVR_MACHINE_FUNCTION_INFO_H 93