Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
This refactoring of ARM machine block size computation creates two ut…
…ility functions so that the size computation is available not only in ConstantIslands but in other passes as well. Differential Revision: https://reviews.llvm.org/D22640 llvm-svn: 276399
- Loading branch information
Sjoerd Meijer
committed
Jul 22, 2016
1 parent
a31c91b
commit 5c0ef83
Showing
5 changed files
with
193 additions
and
123 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,110 @@ | ||
| //===-- ARMBasicBlockInfo.h - Basic Block Information -----------*- C++ -*-===// | ||
| // | ||
| // The LLVM Compiler Infrastructure | ||
| // | ||
| // This file is distributed under the University of Illinois Open Source | ||
| // License. See LICENSE.TXT for details. | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
| // | ||
| // Utility functions and data structure for computing block size. | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
|
|
||
| #ifndef LLVM_LIB_TARGET_ARM_ARMBASICBLOCKINFO_H | ||
| #define LLVM_LIB_TARGET_ARM_ARMBASICBLOCKINFO_H | ||
|
|
||
| #include "ARM.h" | ||
| #include "ARMMachineFunctionInfo.h" | ||
| using namespace llvm; | ||
|
|
||
| namespace llvm { | ||
|
|
||
| /// UnknownPadding - Return the worst case padding that could result from | ||
| /// unknown offset bits. This does not include alignment padding caused by | ||
| /// known offset bits. | ||
| /// | ||
| /// @param LogAlign log2(alignment) | ||
| /// @param KnownBits Number of known low offset bits. | ||
| inline unsigned UnknownPadding(unsigned LogAlign, unsigned KnownBits) { | ||
| if (KnownBits < LogAlign) | ||
| return (1u << LogAlign) - (1u << KnownBits); | ||
| return 0; | ||
| } | ||
|
|
||
| /// BasicBlockInfo - Information about the offset and size of a single | ||
| /// basic block. | ||
| struct BasicBlockInfo { | ||
| /// Offset - Distance from the beginning of the function to the beginning | ||
| /// of this basic block. | ||
| /// | ||
| /// Offsets are computed assuming worst case padding before an aligned | ||
| /// block. This means that subtracting basic block offsets always gives a | ||
| /// conservative estimate of the real distance which may be smaller. | ||
| /// | ||
| /// Because worst case padding is used, the computed offset of an aligned | ||
| /// block may not actually be aligned. | ||
| unsigned Offset; | ||
|
|
||
| /// Size - Size of the basic block in bytes. If the block contains | ||
| /// inline assembly, this is a worst case estimate. | ||
| /// | ||
| /// The size does not include any alignment padding whether from the | ||
| /// beginning of the block, or from an aligned jump table at the end. | ||
| unsigned Size; | ||
|
|
||
| /// KnownBits - The number of low bits in Offset that are known to be | ||
| /// exact. The remaining bits of Offset are an upper bound. | ||
| uint8_t KnownBits; | ||
|
|
||
| /// Unalign - When non-zero, the block contains instructions (inline asm) | ||
| /// of unknown size. The real size may be smaller than Size bytes by a | ||
| /// multiple of 1 << Unalign. | ||
| uint8_t Unalign; | ||
|
|
||
| /// PostAlign - When non-zero, the block terminator contains a .align | ||
| /// directive, so the end of the block is aligned to 1 << PostAlign | ||
| /// bytes. | ||
| uint8_t PostAlign; | ||
|
|
||
| BasicBlockInfo() : Offset(0), Size(0), KnownBits(0), Unalign(0), | ||
| PostAlign(0) {} | ||
|
|
||
| /// Compute the number of known offset bits internally to this block. | ||
| /// This number should be used to predict worst case padding when | ||
| /// splitting the block. | ||
| unsigned internalKnownBits() const { | ||
| unsigned Bits = Unalign ? Unalign : KnownBits; | ||
| // If the block size isn't a multiple of the known bits, assume the | ||
| // worst case padding. | ||
| if (Size & ((1u << Bits) - 1)) | ||
| Bits = countTrailingZeros(Size); | ||
| return Bits; | ||
| } | ||
|
|
||
| /// Compute the offset immediately following this block. If LogAlign is | ||
| /// specified, return the offset the successor block will get if it has | ||
| /// this alignment. | ||
| unsigned postOffset(unsigned LogAlign = 0) const { | ||
| unsigned PO = Offset + Size; | ||
| unsigned LA = std::max(unsigned(PostAlign), LogAlign); | ||
| if (!LA) | ||
| return PO; | ||
| // Add alignment padding from the terminator. | ||
| return PO + UnknownPadding(LA, internalKnownBits()); | ||
| } | ||
|
|
||
| /// Compute the number of known low bits of postOffset. If this block | ||
| /// contains inline asm, the number of known bits drops to the | ||
| /// instruction alignment. An aligned terminator may increase the number | ||
| /// of know bits. | ||
| /// If LogAlign is given, also consider the alignment of the next block. | ||
| unsigned postKnownBits(unsigned LogAlign = 0) const { | ||
| return std::max(std::max(unsigned(PostAlign), LogAlign), | ||
| internalKnownBits()); | ||
| } | ||
| }; | ||
|
|
||
| } // end namespace llvm | ||
|
|
||
| #endif |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,72 @@ | ||
| //===--- ARMComputeBlockSize.cpp - Compute machine block sizes ------------===// | ||
| // | ||
| // The LLVM Compiler Infrastructure | ||
| // | ||
| // This file is distributed under the University of Illinois Open Source | ||
| // License. See LICENSE.TXT for details. | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
|
|
||
| #include "ARM.h" | ||
| #include "ARMBasicBlockInfo.h" | ||
| using namespace llvm; | ||
|
|
||
| namespace llvm { | ||
|
|
||
| // mayOptimizeThumb2Instruction - Returns true if optimizeThumb2Instructions | ||
| // below may shrink MI. | ||
| static bool | ||
| mayOptimizeThumb2Instruction(const MachineInstr *MI) { | ||
| switch(MI->getOpcode()) { | ||
| // optimizeThumb2Instructions. | ||
| case ARM::t2LEApcrel: | ||
| case ARM::t2LDRpci: | ||
| // optimizeThumb2Branches. | ||
| case ARM::t2B: | ||
| case ARM::t2Bcc: | ||
| case ARM::tBcc: | ||
| // optimizeThumb2JumpTables. | ||
| case ARM::t2BR_JT: | ||
| return true; | ||
| } | ||
| return false; | ||
| } | ||
|
|
||
| void computeBlockSize(MachineFunction *MF, MachineBasicBlock *MBB, | ||
| BasicBlockInfo &BBI) { | ||
| const ARMBaseInstrInfo *TII = | ||
| static_cast<const ARMBaseInstrInfo *>(MF->getSubtarget().getInstrInfo()); | ||
| bool isThumb = MF->getInfo<ARMFunctionInfo>()->isThumbFunction(); | ||
| BBI.Size = 0; | ||
| BBI.Unalign = 0; | ||
| BBI.PostAlign = 0; | ||
|
|
||
| for (MachineInstr &I : *MBB) { | ||
| BBI.Size += TII->GetInstSizeInBytes(I); | ||
| // For inline asm, GetInstSizeInBytes returns a conservative estimate. | ||
| // The actual size may be smaller, but still a multiple of the instr size. | ||
| if (I.isInlineAsm()) | ||
| BBI.Unalign = isThumb ? 1 : 2; | ||
| // Also consider instructions that may be shrunk later. | ||
| else if (isThumb && mayOptimizeThumb2Instruction(&I)) | ||
| BBI.Unalign = 1; | ||
| } | ||
|
|
||
| // tBR_JTr contains a .align 2 directive. | ||
| if (!MBB->empty() && MBB->back().getOpcode() == ARM::tBR_JTr) { | ||
| BBI.PostAlign = 2; | ||
| MBB->getParent()->ensureAlignment(2); | ||
| } | ||
| } | ||
|
|
||
| std::vector<BasicBlockInfo> computeAllBlockSizes(MachineFunction *MF) { | ||
| std::vector<BasicBlockInfo> BBInfo; | ||
| BBInfo.resize(MF->getNumBlockIDs()); | ||
|
|
||
| for (MachineBasicBlock &MBB : *MF) | ||
| computeBlockSize(MF, &MBB, BBInfo[MBB.getNumber()]); | ||
|
|
||
| return BBInfo; | ||
| } | ||
|
|
||
| } // end namespace |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters