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: 48 AVRMachineFunctionInfo() 49 : HasSpills(false), HasAllocas(false), HasStackArgs(false), 50 IsInterruptHandler(false), IsSignalHandler(false), 51 CalleeSavedFrameSize(0), VarArgsFrameIndex(0) {} 52 53 explicit AVRMachineFunctionInfo(MachineFunction &MF) 54 : HasSpills(false), HasAllocas(false), HasStackArgs(false), 55 CalleeSavedFrameSize(0), VarArgsFrameIndex(0) { 56 unsigned CallConv = MF.getFunction().getCallingConv(); 57 58 this->IsInterruptHandler = CallConv == CallingConv::AVR_INTR || 59 MF.getFunction().hasFnAttribute("interrupt"); 60 this->IsSignalHandler = CallConv == CallingConv::AVR_SIGNAL || 61 MF.getFunction().hasFnAttribute("signal"); 62 } 63 64 MachineFunctionInfo * 65 clone(BumpPtrAllocator &Allocator, MachineFunction &DestMF, 66 const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB) 67 const override { 68 return DestMF.cloneInfo<AVRMachineFunctionInfo>(*this); 69 } 70 71 bool getHasSpills() const { return HasSpills; } 72 void setHasSpills(bool B) { HasSpills = B; } 73 74 bool getHasAllocas() const { return HasAllocas; } 75 void setHasAllocas(bool B) { HasAllocas = B; } 76 77 bool getHasStackArgs() const { return HasStackArgs; } 78 void setHasStackArgs(bool B) { HasStackArgs = B; } 79 80 /// Checks if the function is some form of interrupt service routine. 81 bool isInterruptOrSignalHandler() const { 82 return isInterruptHandler() || isSignalHandler(); 83 } 84 85 bool isInterruptHandler() const { return IsInterruptHandler; } 86 bool isSignalHandler() const { return IsSignalHandler; } 87 88 unsigned getCalleeSavedFrameSize() const { return CalleeSavedFrameSize; } 89 void setCalleeSavedFrameSize(unsigned Bytes) { CalleeSavedFrameSize = Bytes; } 90 91 int getVarArgsFrameIndex() const { return VarArgsFrameIndex; } 92 void setVarArgsFrameIndex(int Idx) { VarArgsFrameIndex = Idx; } 93 }; 94 95 } // namespace llvm 96 97 #endif // LLVM_AVR_MACHINE_FUNCTION_INFO_H 98