1a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka//===-- MipsLongBranch.cpp - Emit long branches ---------------------------===// 2a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// 3a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// The LLVM Compiler Infrastructure 4a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// 5a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// This file is distributed under the University of Illinois Open Source 6a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// License. See LICENSE.TXT for details. 7a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// 8a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka//===----------------------------------------------------------------------===// 9a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// 10a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// This pass expands a branch or jump instruction into a long branch if its 11a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// offset is too large to fit into its immediate field. 12a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// 13dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines// FIXME: Fix pc-region jump instructions which cross 256MB segment boundaries. 14a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka//===----------------------------------------------------------------------===// 15a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 16a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka#include "Mips.h" 17a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka#include "MCTargetDesc/MipsBaseInfo.h" 18c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines#include "MCTargetDesc/MipsMCNaCl.h" 1937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines#include "MipsMachineFunction.h" 20d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "MipsTargetMachine.h" 21a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka#include "llvm/ADT/Statistic.h" 22a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka#include "llvm/CodeGen/MachineFunctionPass.h" 23a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka#include "llvm/CodeGen/MachineInstrBuilder.h" 240b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Function.h" 25a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka#include "llvm/Support/CommandLine.h" 26a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka#include "llvm/Support/MathExtras.h" 27a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka#include "llvm/Target/TargetInstrInfo.h" 28a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka#include "llvm/Target/TargetMachine.h" 29a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka#include "llvm/Target/TargetRegisterInfo.h" 30a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 31a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakausing namespace llvm; 32a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 33dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "mips-long-branch" 34dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 35a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira HatanakaSTATISTIC(LongBranches, "Number of long branches."); 36a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 37a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakastatic cl::opt<bool> SkipLongBranch( 38a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka "skip-mips-long-branch", 39a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka cl::init(false), 40a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka cl::desc("MIPS: Skip long branch pass."), 41a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka cl::Hidden); 42a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 43a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakastatic cl::opt<bool> ForceLongBranch( 44a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka "force-mips-long-branch", 45a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka cl::init(false), 46a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka cl::desc("MIPS: Expand all branches to long format."), 47a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka cl::Hidden); 48a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 49a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakanamespace { 50a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka typedef MachineBasicBlock::iterator Iter; 51a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka typedef MachineBasicBlock::reverse_iterator ReverseIter; 52a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 53a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka struct MBBInfo { 54273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka uint64_t Size, Address; 55a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka bool HasLongBranch; 56a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MachineInstr *Br; 57a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 58dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MBBInfo() : Size(0), HasLongBranch(false), Br(nullptr) {} 59a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka }; 60a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 61a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka class MipsLongBranch : public MachineFunctionPass { 62a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 63a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka public: 64a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka static char ID; 65a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MipsLongBranch(TargetMachine &tm) 66ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines : MachineFunctionPass(ID), TM(tm), 67ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines IsPIC(TM.getRelocationModel() == Reloc::PIC_), 68ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ABI(static_cast<const MipsTargetMachine &>(TM).getABI()) {} 69a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 70dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const char *getPassName() const override { 71a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka return "Mips Long Branch"; 72a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka } 73a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 74dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool runOnMachineFunction(MachineFunction &F) override; 75a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 76a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka private: 77a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka void splitMBB(MachineBasicBlock *MBB); 78a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka void initMBBInfo(); 79a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka int64_t computeOffset(const MachineInstr *Br); 80a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka void replaceBranch(MachineBasicBlock &MBB, Iter Br, DebugLoc DL, 81a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MachineBasicBlock *MBBOpnd); 82a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka void expandToLongBranch(MBBInfo &Info); 83a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 84a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka const TargetMachine &TM; 85a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MachineFunction *MF; 86a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka SmallVector<MBBInfo, 16> MBBInfos; 87273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka bool IsPIC; 8837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines MipsABIInfo ABI; 89273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka unsigned LongBranchSeqSize; 90a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka }; 91a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 92a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka char MipsLongBranch::ID = 0; 93a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka} // end of anonymous namespace 94a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 95a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka/// createMipsLongBranchPass - Returns a pass that converts branches to long 96a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka/// branches. 97a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira HatanakaFunctionPass *llvm::createMipsLongBranchPass(MipsTargetMachine &tm) { 98a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka return new MipsLongBranch(tm); 99a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka} 100a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 101a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka/// Iterate over list of Br's operands and search for a MachineBasicBlock 102a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka/// operand. 103a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakastatic MachineBasicBlock *getTargetMBB(const MachineInstr &Br) { 104a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka for (unsigned I = 0, E = Br.getDesc().getNumOperands(); I < E; ++I) { 105a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka const MachineOperand &MO = Br.getOperand(I); 106a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 107a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka if (MO.isMBB()) 108a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka return MO.getMBB(); 109a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka } 110a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 111ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines llvm_unreachable("This instruction does not have an MBB operand."); 112a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka} 113a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 114a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// Traverse the list of instructions backwards until a non-debug instruction is 115a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// found or it reaches E. 116a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakastatic ReverseIter getNonDebugInstr(ReverseIter B, ReverseIter E) { 117a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka for (; B != E; ++B) 118a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka if (!B->isDebugValue()) 119a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka return B; 120a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 121a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka return E; 122a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka} 123a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 124a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// Split MBB if it has two direct jumps/branches. 125a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakavoid MipsLongBranch::splitMBB(MachineBasicBlock *MBB) { 126a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka ReverseIter End = MBB->rend(); 127a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka ReverseIter LastBr = getNonDebugInstr(MBB->rbegin(), End); 128a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 129a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // Return if MBB has no branch instructions. 130a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka if ((LastBr == End) || 131a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka (!LastBr->isConditionalBranch() && !LastBr->isUnconditionalBranch())) 132a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka return; 133a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 13436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ReverseIter FirstBr = getNonDebugInstr(std::next(LastBr), End); 135a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 136a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // MBB has only one branch instruction if FirstBr is not a branch 137a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // instruction. 138a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka if ((FirstBr == End) || 139a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka (!FirstBr->isConditionalBranch() && !FirstBr->isUnconditionalBranch())) 140a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka return; 141a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 142a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka assert(!FirstBr->isIndirectBranch() && "Unexpected indirect branch found."); 143a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 144a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // Create a new MBB. Move instructions in MBB to the newly created MBB. 145a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MachineBasicBlock *NewMBB = 146a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MF->CreateMachineBasicBlock(MBB->getBasicBlock()); 147a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 148a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // Insert NewMBB and fix control flow. 149a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MachineBasicBlock *Tgt = getTargetMBB(*FirstBr); 150a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka NewMBB->transferSuccessors(MBB); 151a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka NewMBB->removeSuccessor(Tgt); 152a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MBB->addSuccessor(NewMBB); 153a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MBB->addSuccessor(Tgt); 15436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MF->insert(std::next(MachineFunction::iterator(MBB)), NewMBB); 155a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 156a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka NewMBB->splice(NewMBB->end(), MBB, (++LastBr).base(), MBB->end()); 157a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka} 158a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 159a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// Fill MBBInfos. 160a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakavoid MipsLongBranch::initMBBInfo() { 161a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // Split the MBBs if they have two branches. Each basic block should have at 162a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // most one branch after this loop is executed. 163a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka for (MachineFunction::iterator I = MF->begin(), E = MF->end(); I != E;) 164a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka splitMBB(I++); 165a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 166a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MF->RenumberBlocks(); 167a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MBBInfos.clear(); 168a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MBBInfos.resize(MF->size()); 169a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 17041e632d9e1a55d36cb08b0551ad82a13d9137a5eBill Wendling const MipsInstrInfo *TII = 171ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const MipsInstrInfo *>(MF->getSubtarget().getInstrInfo()); 172a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka for (unsigned I = 0, E = MBBInfos.size(); I < E; ++I) { 173a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MachineBasicBlock *MBB = MF->getBlockNumbered(I); 174a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 175a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // Compute size of MBB. 176a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka for (MachineBasicBlock::instr_iterator MI = MBB->instr_begin(); 177a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MI != MBB->instr_end(); ++MI) 178a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MBBInfos[I].Size += TII->GetInstSizeInBytes(&*MI); 179a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 180a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // Search for MBB's branch instruction. 181a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka ReverseIter End = MBB->rend(); 182a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka ReverseIter Br = getNonDebugInstr(MBB->rbegin(), End); 183a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 184a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka if ((Br != End) && !Br->isIndirectBranch() && 18560287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka (Br->isConditionalBranch() || 18660287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka (Br->isUnconditionalBranch() && 18760287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka TM.getRelocationModel() == Reloc::PIC_))) 188a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MBBInfos[I].Br = (++Br).base(); 189a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka } 190a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka} 191a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 192a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// Compute offset of branch in number of bytes. 193a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakaint64_t MipsLongBranch::computeOffset(const MachineInstr *Br) { 194a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka int64_t Offset = 0; 195a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka int ThisMBB = Br->getParent()->getNumber(); 196a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka int TargetMBB = getTargetMBB(*Br)->getNumber(); 197a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 198a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // Compute offset of a forward branch. 199a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka if (ThisMBB < TargetMBB) { 200a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka for (int N = ThisMBB + 1; N < TargetMBB; ++N) 201a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka Offset += MBBInfos[N].Size; 202a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 203a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka return Offset + 4; 204a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka } 205a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 206a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // Compute offset of a backward branch. 207a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka for (int N = ThisMBB; N >= TargetMBB; --N) 208a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka Offset += MBBInfos[N].Size; 209a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 210a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka return -Offset + 4; 211a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka} 212a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 213a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// Replace Br with a branch which has the opposite condition code and a 214a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// MachineBasicBlock operand MBBOpnd. 215a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakavoid MipsLongBranch::replaceBranch(MachineBasicBlock &MBB, Iter Br, 216a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka DebugLoc DL, MachineBasicBlock *MBBOpnd) { 217ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const MipsInstrInfo *TII = static_cast<const MipsInstrInfo *>( 218ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MBB.getParent()->getSubtarget().getInstrInfo()); 2196daba286836e6fb2351e7ebc248e18a5c80e8a31Akira Hatanaka unsigned NewOpc = TII->getOppositeBranchOpc(Br->getOpcode()); 220a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka const MCInstrDesc &NewDesc = TII->get(NewOpc); 221a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 222a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MachineInstrBuilder MIB = BuildMI(MBB, Br, DL, NewDesc); 223a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 224a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka for (unsigned I = 0, E = Br->getDesc().getNumOperands(); I < E; ++I) { 225a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MachineOperand &MO = Br->getOperand(I); 226a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 227a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka if (!MO.isReg()) { 228a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka assert(MO.isMBB() && "MBB operand expected."); 229a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka break; 230a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka } 231a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 232a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MIB.addReg(MO.getReg()); 233a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka } 234a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 235a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MIB.addMBB(MBBOpnd); 236a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 237ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Br->hasDelaySlot()) { 238ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Bundle the instruction in the delay slot to the newly created branch 239ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // and erase the original branch. 240ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(Br->isBundledWithSucc()); 241ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MachineBasicBlock::instr_iterator II(Br); 242ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MIBundleBuilder(&*MIB).append((++II)->removeFromBundle()); 243ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 244a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka Br->eraseFromParent(); 245a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka} 246a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 247a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka// Expand branch instructions to long branches. 248ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines// TODO: This function has to be fixed for beqz16 and bnez16, because it 249ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines// currently assumes that all branches have 16-bit offsets, and will produce 250ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines// wrong code if branches whose allowed offsets are [-128, -126, ..., 126] 251ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines// are present. 252a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakavoid MipsLongBranch::expandToLongBranch(MBBInfo &I) { 25360287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka MachineBasicBlock::iterator Pos; 25460287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka MachineBasicBlock *MBB = I.Br->getParent(), *TgtMBB = getTargetMBB(*I.Br); 255a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka DebugLoc DL = I.Br->getDebugLoc(); 25660287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka const BasicBlock *BB = MBB->getBasicBlock(); 25760287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka MachineFunction::iterator FallThroughMBB = ++MachineFunction::iterator(MBB); 25860287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka MachineBasicBlock *LongBrMBB = MF->CreateMachineBasicBlock(BB); 259ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const MipsSubtarget &Subtarget = 260ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const MipsSubtarget &>(MF->getSubtarget()); 26141e632d9e1a55d36cb08b0551ad82a13d9137a5eBill Wendling const MipsInstrInfo *TII = 262ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const MipsInstrInfo *>(Subtarget.getInstrInfo()); 26341e632d9e1a55d36cb08b0551ad82a13d9137a5eBill Wendling 26460287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka MF->insert(FallThroughMBB, LongBrMBB); 26560287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka MBB->removeSuccessor(TgtMBB); 26660287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka MBB->addSuccessor(LongBrMBB); 26760287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka 26860287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka if (IsPIC) { 26960287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka MachineBasicBlock *BalTgtMBB = MF->CreateMachineBasicBlock(BB); 27060287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka MF->insert(FallThroughMBB, BalTgtMBB); 27160287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka LongBrMBB->addSuccessor(BalTgtMBB); 27260287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka BalTgtMBB->addSuccessor(TgtMBB); 273a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 274c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // We must select between the MIPS32r6/MIPS64r6 BAL (which is a normal 275c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // instruction) and the pre-MIPS32r6/MIPS64r6 definition (which is an 276c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // pseudo-instruction wrapping BGEZAL). 277c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines unsigned BalOp = Subtarget.hasMips32r6() ? Mips::BAL : Mips::BAL_BR; 278c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 27937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (!ABI.IsN64()) { 280273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // $longbr: 281273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // addiu $sp, $sp, -8 282273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // sw $ra, 0($sp) 283273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // lui $at, %hi($tgt - $baltgt) 284dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // bal $baltgt 285273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // addiu $at, $at, %lo($tgt - $baltgt) 286dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // $baltgt: 287273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // addu $at, $ra, $at 288273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // lw $ra, 0($sp) 289273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // jr $at 290273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // addiu $sp, $sp, 8 291273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // $fallthrough: 292273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // 293273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 294273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka Pos = LongBrMBB->begin(); 295273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 296273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka BuildMI(*LongBrMBB, Pos, DL, TII->get(Mips::ADDiu), Mips::SP) 297273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka .addReg(Mips::SP).addImm(-8); 298273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka BuildMI(*LongBrMBB, Pos, DL, TII->get(Mips::SW)).addReg(Mips::RA) 299273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka .addReg(Mips::SP).addImm(0); 30006180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen 301dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // LUi and ADDiu instructions create 32-bit offset of the target basic 302dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // block from the target of BAL instruction. We cannot use immediate 303dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // value for this offset because it cannot be determined accurately when 304dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // the program has inline assembly statements. We therefore use the 305dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // relocation expressions %hi($tgt-$baltgt) and %lo($tgt-$baltgt) which 306dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // are resolved during the fixup, so the values will always be correct. 307dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 308dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Since we cannot create %hi($tgt-$baltgt) and %lo($tgt-$baltgt) 309dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // expressions at this point (it is possible only at the MC layer), 310dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // we replace LUi and ADDiu with pseudo instructions 311dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // LONG_BRANCH_LUi and LONG_BRANCH_ADDiu, and add both basic 312dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // blocks as operands to these instructions. When lowering these pseudo 313dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // instructions to LUi and ADDiu in the MC layer, we will create 314dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // %hi($tgt-$baltgt) and %lo($tgt-$baltgt) expressions and add them as 315dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // operands to lowered instructions. 316dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 317dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BuildMI(*LongBrMBB, Pos, DL, TII->get(Mips::LONG_BRANCH_LUi), Mips::AT) 318dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines .addMBB(TgtMBB).addMBB(BalTgtMBB); 31906180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen MIBundleBuilder(*LongBrMBB, Pos) 320c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .append(BuildMI(*MF, DL, TII->get(BalOp)).addMBB(BalTgtMBB)) 321c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .append(BuildMI(*MF, DL, TII->get(Mips::LONG_BRANCH_ADDiu), Mips::AT) 322c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .addReg(Mips::AT) 323c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .addMBB(TgtMBB) 324c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .addMBB(BalTgtMBB)); 325273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 326273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka Pos = BalTgtMBB->begin(); 327273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 328273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka BuildMI(*BalTgtMBB, Pos, DL, TII->get(Mips::ADDu), Mips::AT) 329273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka .addReg(Mips::RA).addReg(Mips::AT); 330273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka BuildMI(*BalTgtMBB, Pos, DL, TII->get(Mips::LW), Mips::RA) 331273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka .addReg(Mips::SP).addImm(0); 33206180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen 333ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!Subtarget.isTargetNaCl()) { 334c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines MIBundleBuilder(*BalTgtMBB, Pos) 335c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .append(BuildMI(*MF, DL, TII->get(Mips::JR)).addReg(Mips::AT)) 336c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .append(BuildMI(*MF, DL, TII->get(Mips::ADDiu), Mips::SP) 337c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .addReg(Mips::SP).addImm(8)); 338c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } else { 339c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // In NaCl, modifying the sp is not allowed in branch delay slot. 340c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines BuildMI(*BalTgtMBB, Pos, DL, TII->get(Mips::ADDiu), Mips::SP) 341c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .addReg(Mips::SP).addImm(8); 342c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 343c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines MIBundleBuilder(*BalTgtMBB, Pos) 344c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .append(BuildMI(*MF, DL, TII->get(Mips::JR)).addReg(Mips::AT)) 345c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .append(BuildMI(*MF, DL, TII->get(Mips::NOP))); 346c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 347c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // Bundle-align the target of indirect branch JR. 348c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines TgtMBB->setAlignment(MIPS_NACL_BUNDLE_ALIGN); 349c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } 350273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka } else { 351273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // $longbr: 352273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // daddiu $sp, $sp, -16 353273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // sd $ra, 0($sp) 354dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // daddiu $at, $zero, %hi($tgt - $baltgt) 355273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // dsll $at, $at, 16 356273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // bal $baltgt 357273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // daddiu $at, $at, %lo($tgt - $baltgt) 358dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // $baltgt: 359273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // daddu $at, $ra, $at 360273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // ld $ra, 0($sp) 361273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // jr64 $at 362273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // daddiu $sp, $sp, 16 363273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // $fallthrough: 364273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // 365273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 366dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // We assume the branch is within-function, and that offset is within 367dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // +/- 2GB. High 32 bits will therefore always be zero. 368dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 369dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Note that this will work even if the offset is negative, because 370dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // of the +1 modification that's added in that case. For example, if the 371dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // offset is -1MB (0xFFFFFFFFFFF00000), the computation for %higher is 372dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 373dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 0xFFFFFFFFFFF00000 + 0x80008000 = 0x000000007FF08000 374dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 375dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // and the bits [47:32] are zero. For %highest 376dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 377dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 0xFFFFFFFFFFF00000 + 0x800080008000 = 0x000080007FF08000 378dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 379dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // and the bits [63:48] are zero. 380273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 381273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka Pos = LongBrMBB->begin(); 382273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 383273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka BuildMI(*LongBrMBB, Pos, DL, TII->get(Mips::DADDiu), Mips::SP_64) 384273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka .addReg(Mips::SP_64).addImm(-16); 385273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka BuildMI(*LongBrMBB, Pos, DL, TII->get(Mips::SD)).addReg(Mips::RA_64) 386273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka .addReg(Mips::SP_64).addImm(0); 387dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BuildMI(*LongBrMBB, Pos, DL, TII->get(Mips::LONG_BRANCH_DADDiu), 388dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Mips::AT_64).addReg(Mips::ZERO_64) 389dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines .addMBB(TgtMBB, MipsII::MO_ABS_HI).addMBB(BalTgtMBB); 390273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka BuildMI(*LongBrMBB, Pos, DL, TII->get(Mips::DSLL), Mips::AT_64) 391273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka .addReg(Mips::AT_64).addImm(16); 39206180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen 39306180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen MIBundleBuilder(*LongBrMBB, Pos) 394c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .append(BuildMI(*MF, DL, TII->get(BalOp)).addMBB(BalTgtMBB)) 395c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .append( 396c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines BuildMI(*MF, DL, TII->get(Mips::LONG_BRANCH_DADDiu), Mips::AT_64) 397c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .addReg(Mips::AT_64) 398c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .addMBB(TgtMBB, MipsII::MO_ABS_LO) 399c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines .addMBB(BalTgtMBB)); 400273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 401273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka Pos = BalTgtMBB->begin(); 402273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 403273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka BuildMI(*BalTgtMBB, Pos, DL, TII->get(Mips::DADDu), Mips::AT_64) 404273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka .addReg(Mips::RA_64).addReg(Mips::AT_64); 405273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka BuildMI(*BalTgtMBB, Pos, DL, TII->get(Mips::LD), Mips::RA_64) 406273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka .addReg(Mips::SP_64).addImm(0); 40706180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen 40806180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen MIBundleBuilder(*BalTgtMBB, Pos) 40906180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen .append(BuildMI(*MF, DL, TII->get(Mips::JR64)).addReg(Mips::AT_64)) 41006180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen .append(BuildMI(*MF, DL, TII->get(Mips::DADDiu), Mips::SP_64) 41106180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen .addReg(Mips::SP_64).addImm(16)); 41260287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka } 413c984657c7461ce28b25ca91fdc6caaf2860127fdAkira Hatanaka 414dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(LongBrMBB->size() + BalTgtMBB->size() == LongBranchSeqSize); 41560287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka } else { 41660287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka // $longbr: 41760287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka // j $tgt 41860287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka // nop 41960287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka // $fallthrough: 420a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // 42160287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka Pos = LongBrMBB->begin(); 42260287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka LongBrMBB->addSuccessor(TgtMBB); 42306180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen MIBundleBuilder(*LongBrMBB, Pos) 42406180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen .append(BuildMI(*MF, DL, TII->get(Mips::J)).addMBB(TgtMBB)) 42506180bf3f25f2a9828e4c39f63a883aaa6c9452dJakob Stoklund Olesen .append(BuildMI(*MF, DL, TII->get(Mips::NOP))); 426c984657c7461ce28b25ca91fdc6caaf2860127fdAkira Hatanaka 427c984657c7461ce28b25ca91fdc6caaf2860127fdAkira Hatanaka assert(LongBrMBB->size() == LongBranchSeqSize); 428a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka } 429a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 43060287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka if (I.Br->isUnconditionalBranch()) { 43160287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka // Change branch destination. 43260287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka assert(I.Br->getDesc().getNumOperands() == 1); 43360287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka I.Br->RemoveOperand(0); 43460287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka I.Br->addOperand(MachineOperand::CreateMBB(LongBrMBB)); 43560287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka } else 43660287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka // Change branch destination and reverse condition. 43760287963c7505180500d63b1c1b90f0f4b337430Akira Hatanaka replaceBranch(*MBB, I.Br, DL, FallThroughMBB); 438a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka} 439a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 440a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakastatic void emitGPDisp(MachineFunction &F, const MipsInstrInfo *TII) { 441a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MachineBasicBlock &MBB = F.front(); 442a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MachineBasicBlock::iterator I = MBB.begin(); 443a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka DebugLoc DL = MBB.findDebugLoc(MBB.begin()); 444a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka BuildMI(MBB, I, DL, TII->get(Mips::LUi), Mips::V0) 445a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka .addExternalSymbol("_gp_disp", MipsII::MO_ABS_HI); 446a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka BuildMI(MBB, I, DL, TII->get(Mips::ADDiu), Mips::V0) 447a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka .addReg(Mips::V0).addExternalSymbol("_gp_disp", MipsII::MO_ABS_LO); 448a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MBB.removeLiveIn(Mips::V0); 449a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka} 450a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 451a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanakabool MipsLongBranch::runOnMachineFunction(MachineFunction &F) { 452ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const MipsSubtarget &STI = 453ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const MipsSubtarget &>(F.getSubtarget()); 45441e632d9e1a55d36cb08b0551ad82a13d9137a5eBill Wendling const MipsInstrInfo *TII = 455ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const MipsInstrInfo *>(STI.getInstrInfo()); 456ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines LongBranchSeqSize = 457ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines !IsPIC ? 2 : (ABI.IsN64() ? 10 : (!STI.isTargetNaCl() ? 9 : 10)); 45841e632d9e1a55d36cb08b0551ad82a13d9137a5eBill Wendling 45937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (STI.inMips16Mode() || !STI.enableLongBranchPass()) 460a430cb613b6e93c05f128b04323c57acfd08686dReed Kotler return false; 461a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka if ((TM.getRelocationModel() == Reloc::PIC_) && 462ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const MipsTargetMachine &>(TM).getABI().IsO32() && 463a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka F.getInfo<MipsFunctionInfo>()->globalBaseRegSet()) 464a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka emitGPDisp(F, TII); 465a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 466a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka if (SkipLongBranch) 467bde801b2a7e20f3de62cacc3ef643cf0ed6e2c27Akira Hatanaka return true; 468a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 469a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MF = &F; 470a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka initMBBInfo(); 471a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 4726227d5c690504c7ada5780c00a635b282c46e275Craig Topper SmallVectorImpl<MBBInfo>::iterator I, E = MBBInfos.end(); 473a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka bool EverMadeChange = false, MadeChange = true; 474a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 475a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka while (MadeChange) { 476a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka MadeChange = false; 477a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 478a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka for (I = MBBInfos.begin(); I != E; ++I) { 479a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // Skip if this MBB doesn't have a branch or the branch has already been 480a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka // converted to a long branch. 481a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka if (!I->Br || I->HasLongBranch) 482a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka continue; 483a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 484ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines int ShVal = STI.inMicroMipsMode() ? 2 : 4; 485c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines int64_t Offset = computeOffset(I->Br) / ShVal; 486c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 487ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (STI.isTargetNaCl()) { 488c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // The offset calculation does not include sandboxing instructions 489c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // that will be added later in the MC layer. Since at this point we 490c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // don't know the exact amount of code that "sandboxing" will add, we 491c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // conservatively estimate that code will not grow more than 100%. 492c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines Offset *= 2; 493c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } 49488fc0183be1b1fc94375421c48f8e0ef6fa9139eDaniel Sanders 495273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // Check if offset fits into 16-bit immediate field of branches. 496c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines if (!ForceLongBranch && isInt<16>(Offset)) 497273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka continue; 498a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 499273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka I->HasLongBranch = true; 5004fb08317af55c97f421047f0bdbfdd320ac76936Akira Hatanaka I->Size += LongBranchSeqSize * 4; 501a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka ++LongBranches; 502a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka EverMadeChange = MadeChange = true; 503a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka } 504a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka } 505a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 506273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka if (!EverMadeChange) 507273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka return true; 508273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 509273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // Compute basic block addresses. 510273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka if (TM.getRelocationModel() == Reloc::PIC_) { 511273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka uint64_t Address = 0; 512273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 5134fb08317af55c97f421047f0bdbfdd320ac76936Akira Hatanaka for (I = MBBInfos.begin(); I != E; Address += I->Size, ++I) 514273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka I->Address = Address; 515273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka } 516273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 517273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka // Do the expansion. 518273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka for (I = MBBInfos.begin(); I != E; ++I) 519273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka if (I->HasLongBranch) 520273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka expandToLongBranch(*I); 521273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka 522273956d8c6eed86c8b4d616ecb86f7ff17e127d4Akira Hatanaka MF->RenumberBlocks(); 523a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka 524bde801b2a7e20f3de62cacc3ef643cf0ed6e2c27Akira Hatanaka return true; 525a32ccf92c1d53e0f16d2f29ad1fae75c3aa013a0Akira Hatanaka} 526