LCOV - code coverage report
Current view: top level - lib/Target/ARM - ARMBasicBlockInfo.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 13 13 100.0 %
Date: 2017-09-14 15:23:50 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- ARMBasicBlockInfo.h - Basic Block Information -----------*- C++ -*-===//
       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             : // Utility functions and data structure for computing block size.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_LIB_TARGET_ARM_ARMBASICBLOCKINFO_H
      15             : #define LLVM_LIB_TARGET_ARM_ARMBASICBLOCKINFO_H
      16             : 
      17             : #include "llvm/Support/MathExtras.h"
      18             : #include <algorithm>
      19             : #include <cstdint>
      20             : 
      21             : namespace llvm {
      22             : 
      23             : /// UnknownPadding - Return the worst case padding that could result from
      24             : /// unknown offset bits.  This does not include alignment padding caused by
      25             : /// known offset bits.
      26             : ///
      27             : /// @param LogAlign log2(alignment)
      28             : /// @param KnownBits Number of known low offset bits.
      29             : inline unsigned UnknownPadding(unsigned LogAlign, unsigned KnownBits) {
      30       30260 :   if (KnownBits < LogAlign)
      31       13343 :     return (1u << LogAlign) - (1u << KnownBits);
      32             :   return 0;
      33             : }
      34             : 
      35             : /// BasicBlockInfo - Information about the offset and size of a single
      36             : /// basic block.
      37             : struct BasicBlockInfo {
      38             :   /// Offset - Distance from the beginning of the function to the beginning
      39             :   /// of this basic block.
      40             :   ///
      41             :   /// Offsets are computed assuming worst case padding before an aligned
      42             :   /// block. This means that subtracting basic block offsets always gives a
      43             :   /// conservative estimate of the real distance which may be smaller.
      44             :   ///
      45             :   /// Because worst case padding is used, the computed offset of an aligned
      46             :   /// block may not actually be aligned.
      47             :   unsigned Offset = 0;
      48             : 
      49             :   /// Size - Size of the basic block in bytes.  If the block contains
      50             :   /// inline assembly, this is a worst case estimate.
      51             :   ///
      52             :   /// The size does not include any alignment padding whether from the
      53             :   /// beginning of the block, or from an aligned jump table at the end.
      54             :   unsigned Size = 0;
      55             : 
      56             :   /// KnownBits - The number of low bits in Offset that are known to be
      57             :   /// exact.  The remaining bits of Offset are an upper bound.
      58             :   uint8_t KnownBits = 0;
      59             : 
      60             :   /// Unalign - When non-zero, the block contains instructions (inline asm)
      61             :   /// of unknown size.  The real size may be smaller than Size bytes by a
      62             :   /// multiple of 1 << Unalign.
      63             :   uint8_t Unalign = 0;
      64             : 
      65             :   /// PostAlign - When non-zero, the block terminator contains a .align
      66             :   /// directive, so the end of the block is aligned to 1 << PostAlign
      67             :   /// bytes.
      68             :   uint8_t PostAlign = 0;
      69             : 
      70             :   BasicBlockInfo() = default;
      71             : 
      72             :   /// Compute the number of known offset bits internally to this block.
      73             :   /// This number should be used to predict worst case padding when
      74             :   /// splitting the block.
      75             :   unsigned internalKnownBits() const {
      76       67137 :     unsigned Bits = Unalign ? Unalign : KnownBits;
      77             :     // If the block size isn't a multiple of the known bits, assume the
      78             :     // worst case padding.
      79       67137 :     if (Size & ((1u << Bits) - 1))
      80        8336 :       Bits = countTrailingZeros(Size);
      81             :     return Bits;
      82             :   }
      83             : 
      84             :   /// Compute the offset immediately following this block.  If LogAlign is
      85             :   /// specified, return the offset the successor block will get if it has
      86             :   /// this alignment.
      87       49897 :   unsigned postOffset(unsigned LogAlign = 0) const {
      88       49897 :     unsigned PO = Offset + Size;
      89       99794 :     unsigned LA = std::max(unsigned(PostAlign), LogAlign);
      90       49897 :     if (!LA)
      91             :       return PO;
      92             :     // Add alignment padding from the terminator.
      93       78729 :     return PO + UnknownPadding(LA, internalKnownBits());
      94             :   }
      95             : 
      96             :   /// Compute the number of known low bits of postOffset.  If this block
      97             :   /// contains inline asm, the number of known bits drops to the
      98             :   /// instruction alignment.  An aligned terminator may increase the number
      99             :   /// of know bits.
     100             :   /// If LogAlign is given, also consider the alignment of the next block.
     101       36437 :   unsigned postKnownBits(unsigned LogAlign = 0) const {
     102       72874 :     return std::max(std::max(unsigned(PostAlign), LogAlign),
     103      182185 :                     internalKnownBits());
     104             :   }
     105             : };
     106             : 
     107             : } // end namespace llvm
     108             : 
     109             : #endif // LLVM_LIB_TARGET_ARM_ARMBASICBLOCKINFO_H

Generated by: LCOV version 1.13