LCOV - code coverage report
Current view: top level - include/llvm/CodeGen - MachineJumpTableInfo.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 4 5 80.0 %
Date: 2017-09-14 15:23:50 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- CodeGen/MachineJumpTableInfo.h - Abstract Jump Tables  --*- 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             : // The MachineJumpTableInfo class keeps track of jump tables referenced by
      11             : // lowered switch instructions in the MachineFunction.
      12             : //
      13             : // Instructions reference the address of these jump tables through the use of
      14             : // MO_JumpTableIndex values.  When emitting assembly or machine code, these
      15             : // virtual address references are converted to refer to the address of the
      16             : // function jump tables.
      17             : //
      18             : //===----------------------------------------------------------------------===//
      19             : 
      20             : #ifndef LLVM_CODEGEN_MACHINEJUMPTABLEINFO_H
      21             : #define LLVM_CODEGEN_MACHINEJUMPTABLEINFO_H
      22             : 
      23             : #include <cassert>
      24             : #include <vector>
      25             : 
      26             : namespace llvm {
      27             : 
      28             : class MachineBasicBlock;
      29             : class DataLayout;
      30             : class raw_ostream;
      31             : 
      32             : /// MachineJumpTableEntry - One jump table in the jump table info.
      33             : ///
      34        1450 : struct MachineJumpTableEntry {
      35             :   /// MBBs - The vector of basic blocks from which to create the jump table.
      36             :   std::vector<MachineBasicBlock*> MBBs;
      37             : 
      38             :   explicit MachineJumpTableEntry(const std::vector<MachineBasicBlock*> &M)
      39         231 :   : MBBs(M) {}
      40             : };
      41             : 
      42         217 : class MachineJumpTableInfo {
      43             : public:
      44             :   /// JTEntryKind - This enum indicates how each entry of the jump table is
      45             :   /// represented and emitted.
      46             :   enum JTEntryKind {
      47             :     /// EK_BlockAddress - Each entry is a plain address of block, e.g.:
      48             :     ///     .word LBB123
      49             :     EK_BlockAddress,
      50             : 
      51             :     /// EK_GPRel64BlockAddress - Each entry is an address of block, encoded
      52             :     /// with a relocation as gp-relative, e.g.:
      53             :     ///     .gpdword LBB123
      54             :     EK_GPRel64BlockAddress,
      55             : 
      56             :     /// EK_GPRel32BlockAddress - Each entry is an address of block, encoded
      57             :     /// with a relocation as gp-relative, e.g.:
      58             :     ///     .gprel32 LBB123
      59             :     EK_GPRel32BlockAddress,
      60             : 
      61             :     /// EK_LabelDifference32 - Each entry is the address of the block minus
      62             :     /// the address of the jump table.  This is used for PIC jump tables where
      63             :     /// gprel32 is not supported.  e.g.:
      64             :     ///      .word LBB123 - LJTI1_2
      65             :     /// If the .set directive is supported, this is emitted as:
      66             :     ///      .set L4_5_set_123, LBB123 - LJTI1_2
      67             :     ///      .word L4_5_set_123
      68             :     EK_LabelDifference32,
      69             : 
      70             :     /// EK_Inline - Jump table entries are emitted inline at their point of
      71             :     /// use. It is the responsibility of the target to emit the entries.
      72             :     EK_Inline,
      73             : 
      74             :     /// EK_Custom32 - Each entry is a 32-bit value that is custom lowered by the
      75             :     /// TargetLowering::LowerCustomJumpTableEntry hook.
      76             :     EK_Custom32
      77             :   };
      78             : private:
      79             :   JTEntryKind EntryKind;
      80             :   std::vector<MachineJumpTableEntry> JumpTables;
      81             : public:
      82         434 :   explicit MachineJumpTableInfo(JTEntryKind Kind): EntryKind(Kind) {}
      83             : 
      84             :   JTEntryKind getEntryKind() const { return EntryKind; }
      85             : 
      86             :   /// getEntrySize - Return the size of each entry in the jump table.
      87             :   unsigned getEntrySize(const DataLayout &TD) const;
      88             :   /// getEntryAlignment - Return the alignment of each entry in the jump table.
      89             :   unsigned getEntryAlignment(const DataLayout &TD) const;
      90             : 
      91             :   /// createJumpTableIndex - Create a new jump table.
      92             :   ///
      93             :   unsigned createJumpTableIndex(const std::vector<MachineBasicBlock*> &DestBBs);
      94             : 
      95             :   /// isEmpty - Return true if there are no jump tables.
      96             :   ///
      97             :   bool isEmpty() const { return JumpTables.empty(); }
      98             : 
      99             :   const std::vector<MachineJumpTableEntry> &getJumpTables() const {
     100             :     return JumpTables;
     101             :   }
     102             : 
     103             :   /// RemoveJumpTable - Mark the specific index as being dead.  This will
     104             :   /// prevent it from being emitted.
     105             :   void RemoveJumpTable(unsigned Idx) {
     106           0 :     JumpTables[Idx].MBBs.clear();
     107             :   }
     108             : 
     109             :   /// ReplaceMBBInJumpTables - If Old is the target of any jump tables, update
     110             :   /// the jump tables to branch to New instead.
     111             :   bool ReplaceMBBInJumpTables(MachineBasicBlock *Old, MachineBasicBlock *New);
     112             : 
     113             :   /// ReplaceMBBInJumpTable - If Old is a target of the jump tables, update
     114             :   /// the jump table to branch to New instead.
     115             :   bool ReplaceMBBInJumpTable(unsigned Idx, MachineBasicBlock *Old,
     116             :                              MachineBasicBlock *New);
     117             : 
     118             :   /// print - Used by the MachineFunction printer to print information about
     119             :   /// jump tables.  Implemented in MachineFunction.cpp
     120             :   ///
     121             :   void print(raw_ostream &OS) const;
     122             : 
     123             :   /// dump - Call to stderr.
     124             :   ///
     125             :   void dump() const;
     126             : };
     127             : 
     128             : } // End llvm namespace
     129             : 
     130             : #endif

Generated by: LCOV version 1.13