1 //==-- AArch64CompressJumpTables.cpp - Compress jump tables for AArch64 --====//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 // This pass looks at the basic blocks each jump-table refers to and works out
9 // whether they can be emitted in a compressed form (with 8 or 16-bit
10 // entries). If so, it changes the opcode and flags them in the associated
11 // AArch64FunctionInfo.
13 //===----------------------------------------------------------------------===//
16 #include "AArch64MachineFunctionInfo.h"
17 #include "AArch64Subtarget.h"
18 #include "llvm/ADT/Statistic.h"
19 #include "llvm/CodeGen/MachineFunctionPass.h"
20 #include "llvm/CodeGen/MachineJumpTableInfo.h"
21 #include "llvm/CodeGen/TargetInstrInfo.h"
22 #include "llvm/CodeGen/TargetSubtargetInfo.h"
23 #include "llvm/MC/MCContext.h"
24 #include "llvm/Support/Debug.h"
28 #define DEBUG_TYPE "aarch64-jump-tables"
30 STATISTIC(NumJT8, "Number of jump-tables with 1-byte entries");
31 STATISTIC(NumJT16, "Number of jump-tables with 2-byte entries");
32 STATISTIC(NumJT32, "Number of jump-tables with 4-byte entries");
35 class AArch64CompressJumpTables : public MachineFunctionPass {
36 const TargetInstrInfo *TII;
38 SmallVector<int, 8> BlockInfo;
40 int computeBlockSize(MachineBasicBlock &MBB);
43 bool compressJumpTable(MachineInstr &MI, int Offset);
47 AArch64CompressJumpTables() : MachineFunctionPass(ID) {
48 initializeAArch64CompressJumpTablesPass(*PassRegistry::getPassRegistry());
51 bool runOnMachineFunction(MachineFunction &MF) override;
53 MachineFunctionProperties getRequiredProperties() const override {
54 return MachineFunctionProperties().set(
55 MachineFunctionProperties::Property::NoVRegs);
57 StringRef getPassName() const override {
58 return "AArch64 Compress Jump Tables";
61 char AArch64CompressJumpTables::ID = 0;
64 INITIALIZE_PASS(AArch64CompressJumpTables, DEBUG_TYPE,
65 "AArch64 compress jump tables pass", false, false)
67 int AArch64CompressJumpTables::computeBlockSize(MachineBasicBlock &MBB) {
69 for (const MachineInstr &MI : MBB)
70 Size += TII->getInstSizeInBytes(MI);
74 void AArch64CompressJumpTables::scanFunction() {
76 BlockInfo.resize(MF->getNumBlockIDs());
79 for (MachineBasicBlock &MBB : *MF) {
80 BlockInfo[MBB.getNumber()] = Offset;
81 Offset += computeBlockSize(MBB);
85 bool AArch64CompressJumpTables::compressJumpTable(MachineInstr &MI,
87 if (MI.getOpcode() != AArch64::JumpTableDest32)
90 int JTIdx = MI.getOperand(4).getIndex();
91 auto &JTInfo = *MF->getJumpTableInfo();
92 const MachineJumpTableEntry &JT = JTInfo.getJumpTables()[JTIdx];
94 // The jump-table might have been optimized away.
98 int MaxOffset = std::numeric_limits<int>::min(),
99 MinOffset = std::numeric_limits<int>::max();
100 MachineBasicBlock *MinBlock = nullptr;
101 for (auto Block : JT.MBBs) {
102 int BlockOffset = BlockInfo[Block->getNumber()];
103 assert(BlockOffset % 4 == 0 && "misaligned basic block");
105 MaxOffset = std::max(MaxOffset, BlockOffset);
106 if (BlockOffset <= MinOffset) {
107 MinOffset = BlockOffset;
112 // The ADR instruction needed to calculate the address of the first reachable
113 // basic block can address +/-1MB.
114 if (!isInt<21>(MinOffset - Offset)) {
119 int Span = MaxOffset - MinOffset;
120 auto AFI = MF->getInfo<AArch64FunctionInfo>();
121 if (isUInt<8>(Span / 4)) {
122 AFI->setJumpTableEntryInfo(JTIdx, 1, MinBlock->getSymbol());
123 MI.setDesc(TII->get(AArch64::JumpTableDest8));
126 } else if (isUInt<16>(Span / 4)) {
127 AFI->setJumpTableEntryInfo(JTIdx, 2, MinBlock->getSymbol());
128 MI.setDesc(TII->get(AArch64::JumpTableDest16));
137 bool AArch64CompressJumpTables::runOnMachineFunction(MachineFunction &MFIn) {
138 bool Changed = false;
141 const auto &ST = MF->getSubtarget<AArch64Subtarget>();
142 TII = ST.getInstrInfo();
144 if (ST.force32BitJumpTables() && !MF->getFunction().optForMinSize())
149 for (MachineBasicBlock &MBB : *MF) {
150 int Offset = BlockInfo[MBB.getNumber()];
151 for (MachineInstr &MI : MBB) {
152 Changed |= compressJumpTable(MI, Offset);
153 Offset += TII->getInstSizeInBytes(MI);
160 FunctionPass *llvm::createAArch64CompressJumpTablesPass() {
161 return new AArch64CompressJumpTables();