Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===-- CodeGen/MachineJumpTableInfo.h - Abstract Jump Tables  --*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. // The MachineJumpTableInfo class keeps track of jump tables referenced by
  10. // lowered switch instructions in the MachineFunction.
  11. //
  12. // Instructions reference the address of these jump tables through the use of
  13. // MO_JumpTableIndex values.  When emitting assembly or machine code, these
  14. // virtual address references are converted to refer to the address of the
  15. // function jump tables.
  16. //
  17. //===----------------------------------------------------------------------===//
  18.  
  19. #ifndef LLVM_CODEGEN_MACHINEJUMPTABLEINFO_H
  20. #define LLVM_CODEGEN_MACHINEJUMPTABLEINFO_H
  21.  
  22. #include "llvm/Support/Printable.h"
  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. 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.   : MBBs(M) {}
  40. };
  41.  
  42. 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.   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.     JumpTables[Idx].MBBs.clear();
  107.   }
  108.  
  109.   /// RemoveMBBFromJumpTables - If MBB is present in any jump tables, remove it.
  110.   bool RemoveMBBFromJumpTables(MachineBasicBlock *MBB);
  111.  
  112.   /// ReplaceMBBInJumpTables - If Old is the target of any jump tables, update
  113.   /// the jump tables to branch to New instead.
  114.   bool ReplaceMBBInJumpTables(MachineBasicBlock *Old, MachineBasicBlock *New);
  115.  
  116.   /// ReplaceMBBInJumpTable - If Old is a target of the jump tables, update
  117.   /// the jump table to branch to New instead.
  118.   bool ReplaceMBBInJumpTable(unsigned Idx, MachineBasicBlock *Old,
  119.                              MachineBasicBlock *New);
  120.  
  121.   /// print - Used by the MachineFunction printer to print information about
  122.   /// jump tables.  Implemented in MachineFunction.cpp
  123.   ///
  124.   void print(raw_ostream &OS) const;
  125.  
  126.   /// dump - Call to stderr.
  127.   ///
  128.   void dump() const;
  129. };
  130.  
  131.  
  132. /// Prints a jump table entry reference.
  133. ///
  134. /// The format is:
  135. ///   %jump-table.5       - a jump table entry with index == 5.
  136. ///
  137. /// Usage: OS << printJumpTableEntryReference(Idx) << '\n';
  138. Printable printJumpTableEntryReference(unsigned Idx);
  139.  
  140. } // End llvm namespace
  141.  
  142. #endif
  143.