LCOV - code coverage report
Current view: top level - lib/Target/AVR - AVRInstrInfo.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 162 179 90.5 %
Date: 2018-10-20 13:21:21 Functions: 17 17 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- AVRInstrInfo.cpp - AVR Instruction Information --------------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file contains the AVR implementation of the TargetInstrInfo class.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "AVRInstrInfo.h"
      15             : 
      16             : #include "llvm/ADT/STLExtras.h"
      17             : #include "llvm/CodeGen/MachineConstantPool.h"
      18             : #include "llvm/CodeGen/MachineFrameInfo.h"
      19             : #include "llvm/CodeGen/MachineInstrBuilder.h"
      20             : #include "llvm/CodeGen/MachineMemOperand.h"
      21             : #include "llvm/IR/Constants.h"
      22             : #include "llvm/IR/Function.h"
      23             : #include "llvm/MC/MCContext.h"
      24             : #include "llvm/Support/Debug.h"
      25             : #include "llvm/Support/ErrorHandling.h"
      26             : #include "llvm/Support/TargetRegistry.h"
      27             : 
      28             : #include "AVR.h"
      29             : #include "AVRMachineFunctionInfo.h"
      30             : #include "AVRRegisterInfo.h"
      31             : #include "AVRTargetMachine.h"
      32             : #include "MCTargetDesc/AVRMCTargetDesc.h"
      33             : 
      34             : #define GET_INSTRINFO_CTOR_DTOR
      35             : #include "AVRGenInstrInfo.inc"
      36             : 
      37             : namespace llvm {
      38             : 
      39         119 : AVRInstrInfo::AVRInstrInfo()
      40         119 :     : AVRGenInstrInfo(AVR::ADJCALLSTACKDOWN, AVR::ADJCALLSTACKUP), RI() {}
      41             : 
      42         424 : void AVRInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
      43             :                                MachineBasicBlock::iterator MI,
      44             :                                const DebugLoc &DL, unsigned DestReg,
      45             :                                unsigned SrcReg, bool KillSrc) const {
      46         424 :   const AVRSubtarget &STI = MBB.getParent()->getSubtarget<AVRSubtarget>();
      47         424 :   const AVRRegisterInfo &TRI = *STI.getRegisterInfo();
      48             :   unsigned Opc;
      49             : 
      50             :   // Not all AVR devices support the 16-bit `MOVW` instruction.
      51         848 :   if (AVR::DREGSRegClass.contains(DestReg, SrcReg)) {
      52         371 :     if (STI.hasMOVW()) {
      53         681 :       BuildMI(MBB, MI, DL, get(AVR::MOVWRdRr), DestReg)
      54         227 :           .addReg(SrcReg, getKillRegState(KillSrc));
      55             :     } else {
      56             :       unsigned DestLo, DestHi, SrcLo, SrcHi;
      57             : 
      58         144 :       TRI.splitReg(DestReg, DestLo, DestHi);
      59         144 :       TRI.splitReg(SrcReg,  SrcLo,  SrcHi);
      60             : 
      61             :       // Copy each individual register with the `MOV` instruction.
      62         288 :       BuildMI(MBB, MI, DL, get(AVR::MOVRdRr), DestLo)
      63         144 :         .addReg(SrcLo, getKillRegState(KillSrc));
      64         432 :       BuildMI(MBB, MI, DL, get(AVR::MOVRdRr), DestHi)
      65         144 :         .addReg(SrcHi, getKillRegState(KillSrc));
      66             :     }
      67             :   } else {
      68         106 :     if (AVR::GPR8RegClass.contains(DestReg, SrcReg)) {
      69             :       Opc = AVR::MOVRdRr;
      70          18 :     } else if (SrcReg == AVR::SP && AVR::DREGSRegClass.contains(DestReg)) {
      71             :       Opc = AVR::SPREAD;
      72          12 :     } else if (DestReg == AVR::SP && AVR::DREGSRegClass.contains(SrcReg)) {
      73             :       Opc = AVR::SPWRITE;
      74             :     } else {
      75           0 :       llvm_unreachable("Impossible reg-to-reg copy");
      76             :     }
      77             : 
      78         159 :     BuildMI(MBB, MI, DL, get(Opc), DestReg)
      79          53 :         .addReg(SrcReg, getKillRegState(KillSrc));
      80             :   }
      81         424 : }
      82             : 
      83        4492 : unsigned AVRInstrInfo::isLoadFromStackSlot(const MachineInstr &MI,
      84             :                                            int &FrameIndex) const {
      85        8984 :   switch (MI.getOpcode()) {
      86          27 :   case AVR::LDDRdPtrQ:
      87             :   case AVR::LDDWRdYQ: { //:FIXME: remove this once PR13375 gets fixed
      88          54 :     if (MI.getOperand(1).isFI() && MI.getOperand(2).isImm() &&
      89          27 :         MI.getOperand(2).getImm() == 0) {
      90          27 :       FrameIndex = MI.getOperand(1).getIndex();
      91          27 :       return MI.getOperand(0).getReg();
      92             :     }
      93             :     break;
      94             :   }
      95             :   default:
      96             :     break;
      97             :   }
      98             : 
      99             :   return 0;
     100             : }
     101             : 
     102        3024 : unsigned AVRInstrInfo::isStoreToStackSlot(const MachineInstr &MI,
     103             :                                           int &FrameIndex) const {
     104        6048 :   switch (MI.getOpcode()) {
     105           5 :   case AVR::STDPtrQRr:
     106             :   case AVR::STDWPtrQRr: {
     107          10 :     if (MI.getOperand(0).isFI() && MI.getOperand(1).isImm() &&
     108           4 :         MI.getOperand(1).getImm() == 0) {
     109           4 :       FrameIndex = MI.getOperand(0).getIndex();
     110           4 :       return MI.getOperand(2).getReg();
     111             :     }
     112             :     break;
     113             :   }
     114             :   default:
     115             :     break;
     116             :   }
     117             : 
     118             :   return 0;
     119             : }
     120             : 
     121          22 : void AVRInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
     122             :                                        MachineBasicBlock::iterator MI,
     123             :                                        unsigned SrcReg, bool isKill,
     124             :                                        int FrameIndex,
     125             :                                        const TargetRegisterClass *RC,
     126             :                                        const TargetRegisterInfo *TRI) const {
     127          22 :   MachineFunction &MF = *MBB.getParent();
     128             :   AVRMachineFunctionInfo *AFI = MF.getInfo<AVRMachineFunctionInfo>();
     129             : 
     130             :   AFI->setHasSpills(true);
     131             : 
     132          22 :   DebugLoc DL;
     133          22 :   if (MI != MBB.end()) {
     134             :     DL = MI->getDebugLoc();
     135             :   }
     136             : 
     137          22 :   const MachineFrameInfo &MFI = MF.getFrameInfo();
     138             : 
     139          22 :   MachineMemOperand *MMO = MF.getMachineMemOperand(
     140             :       MachinePointerInfo::getFixedStack(MF, FrameIndex),
     141             :       MachineMemOperand::MOStore, MFI.getObjectSize(FrameIndex),
     142             :       MFI.getObjectAlignment(FrameIndex));
     143             : 
     144             :   unsigned Opcode = 0;
     145          22 :   if (TRI->isTypeLegalForClass(*RC, MVT::i8)) {
     146             :     Opcode = AVR::STDPtrQRr;
     147          21 :   } else if (TRI->isTypeLegalForClass(*RC, MVT::i16)) {
     148             :     Opcode = AVR::STDWPtrQRr;
     149             :   } else {
     150           0 :     llvm_unreachable("Cannot store this register into a stack slot!");
     151             :   }
     152             : 
     153          66 :   BuildMI(MBB, MI, DL, get(Opcode))
     154             :       .addFrameIndex(FrameIndex)
     155             :       .addImm(0)
     156          22 :       .addReg(SrcReg, getKillRegState(isKill))
     157             :       .addMemOperand(MMO);
     158          22 : }
     159             : 
     160          25 : void AVRInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
     161             :                                         MachineBasicBlock::iterator MI,
     162             :                                         unsigned DestReg, int FrameIndex,
     163             :                                         const TargetRegisterClass *RC,
     164             :                                         const TargetRegisterInfo *TRI) const {
     165          25 :   DebugLoc DL;
     166          25 :   if (MI != MBB.end()) {
     167             :     DL = MI->getDebugLoc();
     168             :   }
     169             : 
     170          25 :   MachineFunction &MF = *MBB.getParent();
     171          25 :   const MachineFrameInfo &MFI = MF.getFrameInfo();
     172             : 
     173          25 :   MachineMemOperand *MMO = MF.getMachineMemOperand(
     174             :       MachinePointerInfo::getFixedStack(MF, FrameIndex),
     175             :       MachineMemOperand::MOLoad, MFI.getObjectSize(FrameIndex),
     176             :       MFI.getObjectAlignment(FrameIndex));
     177             : 
     178             :   unsigned Opcode = 0;
     179          25 :   if (TRI->isTypeLegalForClass(*RC, MVT::i8)) {
     180             :     Opcode = AVR::LDDRdPtrQ;
     181          25 :   } else if (TRI->isTypeLegalForClass(*RC, MVT::i16)) {
     182             :     // Opcode = AVR::LDDWRdPtrQ;
     183             :     //:FIXME: remove this once PR13375 gets fixed
     184             :     Opcode = AVR::LDDWRdYQ;
     185             :   } else {
     186           0 :     llvm_unreachable("Cannot load this register from a stack slot!");
     187             :   }
     188             : 
     189          50 :   BuildMI(MBB, MI, DL, get(Opcode), DestReg)
     190             :       .addFrameIndex(FrameIndex)
     191             :       .addImm(0)
     192             :       .addMemOperand(MMO);
     193          25 : }
     194             : 
     195         387 : const MCInstrDesc &AVRInstrInfo::getBrCond(AVRCC::CondCodes CC) const {
     196         387 :   switch (CC) {
     197           0 :   default:
     198           0 :     llvm_unreachable("Unknown condition code!");
     199         177 :   case AVRCC::COND_EQ:
     200         354 :     return get(AVR::BREQk);
     201         157 :   case AVRCC::COND_NE:
     202         314 :     return get(AVR::BRNEk);
     203           4 :   case AVRCC::COND_GE:
     204           8 :     return get(AVR::BRGEk);
     205           6 :   case AVRCC::COND_LT:
     206          12 :     return get(AVR::BRLTk);
     207          18 :   case AVRCC::COND_SH:
     208          36 :     return get(AVR::BRSHk);
     209          15 :   case AVRCC::COND_LO:
     210          30 :     return get(AVR::BRLOk);
     211           6 :   case AVRCC::COND_MI:
     212          12 :     return get(AVR::BRMIk);
     213           4 :   case AVRCC::COND_PL:
     214           8 :     return get(AVR::BRPLk);
     215             :   }
     216             : }
     217             : 
     218        3471 : AVRCC::CondCodes AVRInstrInfo::getCondFromBranchOpc(unsigned Opc) const {
     219             :   switch (Opc) {
     220             :   default:
     221             :     return AVRCC::COND_INVALID;
     222             :   case AVR::BREQk:
     223             :     return AVRCC::COND_EQ;
     224             :   case AVR::BRNEk:
     225             :     return AVRCC::COND_NE;
     226             :   case AVR::BRSHk:
     227             :     return AVRCC::COND_SH;
     228             :   case AVR::BRLOk:
     229             :     return AVRCC::COND_LO;
     230             :   case AVR::BRMIk:
     231             :     return AVRCC::COND_MI;
     232             :   case AVR::BRPLk:
     233             :     return AVRCC::COND_PL;
     234             :   case AVR::BRGEk:
     235             :     return AVRCC::COND_GE;
     236             :   case AVR::BRLTk:
     237             :     return AVRCC::COND_LT;
     238             :   }
     239             : }
     240             : 
     241         344 : AVRCC::CondCodes AVRInstrInfo::getOppositeCondition(AVRCC::CondCodes CC) const {
     242             :   switch (CC) {
     243           0 :   default:
     244           0 :     llvm_unreachable("Invalid condition!");
     245             :   case AVRCC::COND_EQ:
     246             :     return AVRCC::COND_NE;
     247             :   case AVRCC::COND_NE:
     248             :     return AVRCC::COND_EQ;
     249             :   case AVRCC::COND_SH:
     250             :     return AVRCC::COND_LO;
     251             :   case AVRCC::COND_LO:
     252             :     return AVRCC::COND_SH;
     253             :   case AVRCC::COND_GE:
     254             :     return AVRCC::COND_LT;
     255             :   case AVRCC::COND_LT:
     256             :     return AVRCC::COND_GE;
     257             :   case AVRCC::COND_MI:
     258             :     return AVRCC::COND_PL;
     259             :   case AVRCC::COND_PL:
     260             :     return AVRCC::COND_MI;
     261             :   }
     262             : }
     263             : 
     264        5917 : bool AVRInstrInfo::analyzeBranch(MachineBasicBlock &MBB,
     265             :                                  MachineBasicBlock *&TBB,
     266             :                                  MachineBasicBlock *&FBB,
     267             :                                  SmallVectorImpl<MachineOperand> &Cond,
     268             :                                  bool AllowModify) const {
     269             :   // Start from the bottom of the block and work up, examining the
     270             :   // terminator instructions.
     271        5917 :   MachineBasicBlock::iterator I = MBB.end();
     272             :   MachineBasicBlock::iterator UnCondBrIter = MBB.end();
     273             : 
     274        9804 :   while (I != MBB.begin()) {
     275             :     --I;
     276             :     if (I->isDebugInstr()) {
     277             :       continue;
     278             :     }
     279             : 
     280             :     // Working from the bottom, when we see a non-terminator
     281             :     // instruction, we're done.
     282        9508 :     if (!isUnpredicatedTerminator(*I)) {
     283             :       break;
     284             :     }
     285             : 
     286             :     // A terminator that isn't a branch can't easily be handled
     287             :     // by this analysis.
     288        9974 :     if (!I->getDesc().isBranch()) {
     289             :       return true;
     290             :     }
     291             : 
     292             :     // Handle unconditional branches.
     293             :     //:TODO: add here jmp
     294        3900 :     if (I->getOpcode() == AVR::RJMPk) {
     295             :       UnCondBrIter = I;
     296             : 
     297        1227 :       if (!AllowModify) {
     298         366 :         TBB = I->getOperand(0).getMBB();
     299         366 :         continue;
     300             :       }
     301             : 
     302             :       // If the block has any instructions after a JMP, delete them.
     303         861 :       while (std::next(I) != MBB.end()) {
     304           0 :         std::next(I)->eraseFromParent();
     305             :       }
     306             : 
     307             :       Cond.clear();
     308         861 :       FBB = 0;
     309             : 
     310             :       // Delete the JMP if it's equivalent to a fall-through.
     311         861 :       if (MBB.isLayoutSuccessor(I->getOperand(0).getMBB())) {
     312         117 :         TBB = 0;
     313         117 :         I->eraseFromParent();
     314         117 :         I = MBB.end();
     315             :         UnCondBrIter = MBB.end();
     316         117 :         continue;
     317             :       }
     318             : 
     319             :       // TBB is used to indicate the unconditinal destination.
     320         744 :       TBB = I->getOperand(0).getMBB();
     321         744 :       continue;
     322             :     }
     323             : 
     324             :     // Handle conditional branches.
     325        2673 :     AVRCC::CondCodes BranchCode = getCondFromBranchOpc(I->getOpcode());
     326        2673 :     if (BranchCode == AVRCC::COND_INVALID) {
     327             :       return true; // Can't handle indirect branch.
     328             :     }
     329             : 
     330             :     // Working from the bottom, handle the first conditional branch.
     331        2660 :     if (Cond.empty()) {
     332        2660 :       MachineBasicBlock *TargetBB = I->getOperand(0).getMBB();
     333        2846 :       if (AllowModify && UnCondBrIter != MBB.end() &&
     334         186 :           MBB.isLayoutSuccessor(TargetBB)) {
     335             :         // If we can modify the code and it ends in something like:
     336             :         //
     337             :         //     jCC L1
     338             :         //     jmp L2
     339             :         //   L1:
     340             :         //     ...
     341             :         //   L2:
     342             :         //
     343             :         // Then we can change this to:
     344             :         //
     345             :         //     jnCC L2
     346             :         //   L1:
     347             :         //     ...
     348             :         //   L2:
     349             :         //
     350             :         // Which is a bit more efficient.
     351             :         // We conditionally jump to the fall-through block.
     352          44 :         BranchCode = getOppositeCondition(BranchCode);
     353          44 :         unsigned JNCC = getBrCond(BranchCode).getOpcode();
     354          44 :         MachineBasicBlock::iterator OldInst = I;
     355             : 
     356          88 :         BuildMI(MBB, UnCondBrIter, MBB.findDebugLoc(I), get(JNCC))
     357          44 :             .addMBB(UnCondBrIter->getOperand(0).getMBB());
     358          88 :         BuildMI(MBB, UnCondBrIter, MBB.findDebugLoc(I), get(AVR::RJMPk))
     359             :             .addMBB(TargetBB);
     360             : 
     361          44 :         OldInst->eraseFromParent();
     362          44 :         UnCondBrIter->eraseFromParent();
     363             : 
     364             :         // Restart the analysis.
     365             :         UnCondBrIter = MBB.end();
     366          44 :         I = MBB.end();
     367             :         continue;
     368             :       }
     369             : 
     370        2616 :       FBB = TBB;
     371        2616 :       TBB = I->getOperand(0).getMBB();
     372        5232 :       Cond.push_back(MachineOperand::CreateImm(BranchCode));
     373        2616 :       continue;
     374             :     }
     375             : 
     376             :     // Handle subsequent conditional branches. Only handle the case where all
     377             :     // conditional branches branch to the same destination.
     378             :     assert(Cond.size() == 1);
     379             :     assert(TBB);
     380             : 
     381             :     // Only handle the case where all conditional branches branch to
     382             :     // the same destination.
     383           0 :     if (TBB != I->getOperand(0).getMBB()) {
     384             :       return true;
     385             :     }
     386             : 
     387           0 :     AVRCC::CondCodes OldBranchCode = (AVRCC::CondCodes)Cond[0].getImm();
     388             :     // If the conditions are the same, we can leave them alone.
     389           0 :     if (OldBranchCode == BranchCode) {
     390             :       continue;
     391             :     }
     392             : 
     393             :     return true;
     394             :   }
     395             : 
     396             :   return false;
     397             : }
     398             : 
     399         463 : unsigned AVRInstrInfo::insertBranch(MachineBasicBlock &MBB,
     400             :                                     MachineBasicBlock *TBB,
     401             :                                     MachineBasicBlock *FBB,
     402             :                                     ArrayRef<MachineOperand> Cond,
     403             :                                     const DebugLoc &DL,
     404             :                                     int *BytesAdded) const {
     405         463 :   if (BytesAdded) *BytesAdded = 0;
     406             : 
     407             :   // Shouldn't be a fall through.
     408             :   assert(TBB && "insertBranch must not be told to insert a fallthrough");
     409             :   assert((Cond.size() == 1 || Cond.size() == 0) &&
     410             :          "AVR branch conditions have one component!");
     411             : 
     412         463 :   if (Cond.empty()) {
     413             :     assert(!FBB && "Unconditional branch with multiple successors!");
     414         151 :     auto &MI = *BuildMI(&MBB, DL, get(AVR::RJMPk)).addMBB(TBB);
     415         151 :     if (BytesAdded)
     416           3 :       *BytesAdded += getInstSizeInBytes(MI);
     417         151 :     return 1;
     418             :   }
     419             : 
     420             :   // Conditional branch.
     421             :   unsigned Count = 0;
     422         312 :   AVRCC::CondCodes CC = (AVRCC::CondCodes)Cond[0].getImm();
     423         312 :   auto &CondMI = *BuildMI(&MBB, DL, getBrCond(CC)).addMBB(TBB);
     424             : 
     425         312 :   if (BytesAdded) *BytesAdded += getInstSizeInBytes(CondMI);
     426             :   ++Count;
     427             : 
     428         312 :   if (FBB) {
     429             :     // Two-way Conditional branch. Insert the second branch.
     430          56 :     auto &MI = *BuildMI(&MBB, DL, get(AVR::RJMPk)).addMBB(FBB);
     431          56 :     if (BytesAdded) *BytesAdded += getInstSizeInBytes(MI);
     432             :     ++Count;
     433             :   }
     434             : 
     435             :   return Count;
     436             : }
     437             : 
     438         501 : unsigned AVRInstrInfo::removeBranch(MachineBasicBlock &MBB,
     439             :                                     int *BytesRemoved) const {
     440         501 :   if (BytesRemoved) *BytesRemoved = 0;
     441             : 
     442         501 :   MachineBasicBlock::iterator I = MBB.end();
     443             :   unsigned Count = 0;
     444             : 
     445        1006 :   while (I != MBB.begin()) {
     446             :     --I;
     447             :     if (I->isDebugInstr()) {
     448             :       continue;
     449             :     }
     450             :     //:TODO: add here the missing jmp instructions once they are implemented
     451             :     // like jmp, {e}ijmp, and other cond branches, ...
     452        1788 :     if (I->getOpcode() != AVR::RJMPk &&
     453         798 :         getCondFromBranchOpc(I->getOpcode()) == AVRCC::COND_INVALID) {
     454             :       break;
     455             :     }
     456             : 
     457             :     // Remove the branch.
     458         505 :     if (BytesRemoved) *BytesRemoved += getInstSizeInBytes(*I);
     459         505 :     I->eraseFromParent();
     460         505 :     I = MBB.end();
     461         505 :     ++Count;
     462             :   }
     463             : 
     464         501 :   return Count;
     465             : }
     466             : 
     467         300 : bool AVRInstrInfo::reverseBranchCondition(
     468             :     SmallVectorImpl<MachineOperand> &Cond) const {
     469             :   assert(Cond.size() == 1 && "Invalid AVR branch condition!");
     470             : 
     471         300 :   AVRCC::CondCodes CC = static_cast<AVRCC::CondCodes>(Cond[0].getImm());
     472         300 :   Cond[0].setImm(getOppositeCondition(CC));
     473             : 
     474         300 :   return false;
     475             : }
     476             : 
     477       28522 : unsigned AVRInstrInfo::getInstSizeInBytes(const MachineInstr &MI) const {
     478       28522 :   unsigned Opcode = MI.getOpcode();
     479             : 
     480             :   switch (Opcode) {
     481             :   // A regular instruction
     482       12042 :   default: {
     483       12042 :     const MCInstrDesc &Desc = get(Opcode);
     484       24084 :     return Desc.getSize();
     485             :   }
     486             :   case TargetOpcode::EH_LABEL:
     487             :   case TargetOpcode::IMPLICIT_DEF:
     488             :   case TargetOpcode::KILL:
     489             :   case TargetOpcode::DBG_VALUE:
     490             :     return 0;
     491       16463 :   case TargetOpcode::INLINEASM: {
     492       16463 :     const MachineFunction &MF = *MI.getParent()->getParent();
     493       16463 :     const AVRTargetMachine &TM = static_cast<const AVRTargetMachine&>(MF.getTarget());
     494       16463 :     const AVRSubtarget &STI = MF.getSubtarget<AVRSubtarget>();
     495       16463 :     const TargetInstrInfo &TII = *STI.getInstrInfo();
     496             : 
     497       16463 :     return TII.getInlineAsmLength(MI.getOperand(0).getSymbolName(),
     498       16463 :                                   *TM.getMCAsmInfo());
     499             :   }
     500             :   }
     501             : }
     502             : 
     503             : MachineBasicBlock *
     504         433 : AVRInstrInfo::getBranchDestBlock(const MachineInstr &MI) const {
     505         866 :   switch (MI.getOpcode()) {
     506           0 :   default:
     507           0 :     llvm_unreachable("unexpected opcode!");
     508         433 :   case AVR::JMPk:
     509             :   case AVR::CALLk:
     510             :   case AVR::RCALLk:
     511             :   case AVR::RJMPk:
     512             :   case AVR::BREQk:
     513             :   case AVR::BRNEk:
     514             :   case AVR::BRSHk:
     515             :   case AVR::BRLOk:
     516             :   case AVR::BRMIk:
     517             :   case AVR::BRPLk:
     518             :   case AVR::BRGEk:
     519             :   case AVR::BRLTk:
     520         433 :     return MI.getOperand(0).getMBB();
     521           0 :   case AVR::BRBSsk:
     522             :   case AVR::BRBCsk:
     523           0 :     return MI.getOperand(1).getMBB();
     524             :   case AVR::SBRCRrB:
     525             :   case AVR::SBRSRrB:
     526             :   case AVR::SBICAb:
     527             :   case AVR::SBISAb:
     528             :     llvm_unreachable("unimplemented branch instructions");
     529             :   }
     530             : }
     531             : 
     532         433 : bool AVRInstrInfo::isBranchOffsetInRange(unsigned BranchOp,
     533             :                                          int64_t BrOffset) const {
     534             : 
     535         433 :   switch (BranchOp) {
     536           0 :   default:
     537           0 :     llvm_unreachable("unexpected opcode!");
     538             :   case AVR::JMPk:
     539             :   case AVR::CALLk:
     540             :     return true;
     541             :   case AVR::RCALLk:
     542             :   case AVR::RJMPk:
     543             :     return isIntN(13, BrOffset);
     544             :   case AVR::BRBSsk:
     545             :   case AVR::BRBCsk:
     546             :   case AVR::BREQk:
     547             :   case AVR::BRNEk:
     548             :   case AVR::BRSHk:
     549             :   case AVR::BRLOk:
     550             :   case AVR::BRMIk:
     551             :   case AVR::BRPLk:
     552             :   case AVR::BRGEk:
     553             :   case AVR::BRLTk:
     554             :     return isIntN(7, BrOffset);
     555             :   }
     556             : }
     557             : 
     558           3 : unsigned AVRInstrInfo::insertIndirectBranch(MachineBasicBlock &MBB,
     559             :                                             MachineBasicBlock &NewDestBB,
     560             :                                             const DebugLoc &DL,
     561             :                                             int64_t BrOffset,
     562             :                                             RegScavenger *RS) const {
     563             :     // This method inserts a *direct* branch (JMP), despite its name.
     564             :     // LLVM calls this method to fixup unconditional branches; it never calls
     565             :     // insertBranch or some hypothetical "insertDirectBranch".
     566             :     // See lib/CodeGen/RegisterRelaxation.cpp for details.
     567             :     // We end up here when a jump is too long for a RJMP instruction.
     568           3 :     auto &MI = *BuildMI(&MBB, DL, get(AVR::JMPk)).addMBB(&NewDestBB);
     569             : 
     570           3 :     return getInstSizeInBytes(MI);
     571             : }
     572             : 
     573             : } // end of namespace llvm
     574             : 

Generated by: LCOV version 1.13