Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

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

  1. //===- CodeGen/MachineConstantPool.h - Abstract Constant Pool ---*- 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. /// @file
  10. /// This file declares the MachineConstantPool class which is an abstract
  11. /// constant pool to keep track of constants referenced by a function.
  12. //
  13. //===----------------------------------------------------------------------===//
  14.  
  15. #ifndef LLVM_CODEGEN_MACHINECONSTANTPOOL_H
  16. #define LLVM_CODEGEN_MACHINECONSTANTPOOL_H
  17.  
  18. #include "llvm/ADT/DenseSet.h"
  19. #include "llvm/MC/SectionKind.h"
  20. #include "llvm/Support/Alignment.h"
  21. #include <climits>
  22. #include <vector>
  23.  
  24. namespace llvm {
  25.  
  26. class Constant;
  27. class DataLayout;
  28. class FoldingSetNodeID;
  29. class MachineConstantPool;
  30. class raw_ostream;
  31. class Type;
  32.  
  33. /// Abstract base class for all machine specific constantpool value subclasses.
  34. ///
  35. class MachineConstantPoolValue {
  36.   virtual void anchor();
  37.  
  38.   Type *Ty;
  39.  
  40. public:
  41.   explicit MachineConstantPoolValue(Type *ty) : Ty(ty) {}
  42.   virtual ~MachineConstantPoolValue() = default;
  43.  
  44.   Type *getType() const { return Ty; }
  45.  
  46.   virtual unsigned getSizeInBytes(const DataLayout &DL) const;
  47.  
  48.   virtual int getExistingMachineCPValue(MachineConstantPool *CP,
  49.                                         Align Alignment) = 0;
  50.  
  51.   virtual void addSelectionDAGCSEId(FoldingSetNodeID &ID) = 0;
  52.  
  53.   /// print - Implement operator<<
  54.   virtual void print(raw_ostream &O) const = 0;
  55. };
  56.  
  57. inline raw_ostream &operator<<(raw_ostream &OS,
  58.                                const MachineConstantPoolValue &V) {
  59.   V.print(OS);
  60.   return OS;
  61. }
  62.  
  63. /// This class is a data container for one entry in a MachineConstantPool.
  64. /// It contains a pointer to the value and an offset from the start of
  65. /// the constant pool.
  66. /// An entry in a MachineConstantPool
  67. class MachineConstantPoolEntry {
  68. public:
  69.   /// The constant itself.
  70.   union {
  71.     const Constant *ConstVal;
  72.     MachineConstantPoolValue *MachineCPVal;
  73.   } Val;
  74.  
  75.   /// The required alignment for this entry.
  76.   Align Alignment;
  77.  
  78.   bool IsMachineConstantPoolEntry;
  79.  
  80.   MachineConstantPoolEntry(const Constant *V, Align A)
  81.       : Alignment(A), IsMachineConstantPoolEntry(false) {
  82.     Val.ConstVal = V;
  83.   }
  84.  
  85.   MachineConstantPoolEntry(MachineConstantPoolValue *V, Align A)
  86.       : Alignment(A), IsMachineConstantPoolEntry(true) {
  87.     Val.MachineCPVal = V;
  88.   }
  89.  
  90.   /// isMachineConstantPoolEntry - Return true if the MachineConstantPoolEntry
  91.   /// is indeed a target specific constantpool entry, not a wrapper over a
  92.   /// Constant.
  93.   bool isMachineConstantPoolEntry() const { return IsMachineConstantPoolEntry; }
  94.  
  95.   Align getAlign() const { return Alignment; }
  96.  
  97.   unsigned getSizeInBytes(const DataLayout &DL) const;
  98.  
  99.   /// This method classifies the entry according to whether or not it may
  100.   /// generate a relocation entry.  This must be conservative, so if it might
  101.   /// codegen to a relocatable entry, it should say so.
  102.   bool needsRelocation() const;
  103.  
  104.   SectionKind getSectionKind(const DataLayout *DL) const;
  105. };
  106.  
  107. /// The MachineConstantPool class keeps track of constants referenced by a
  108. /// function which must be spilled to memory.  This is used for constants which
  109. /// are unable to be used directly as operands to instructions, which typically
  110. /// include floating point and large integer constants.
  111. ///
  112. /// Instructions reference the address of these constant pool constants through
  113. /// the use of MO_ConstantPoolIndex values.  When emitting assembly or machine
  114. /// code, these virtual address references are converted to refer to the
  115. /// address of the function constant pool values.
  116. /// The machine constant pool.
  117. class MachineConstantPool {
  118.   Align PoolAlignment; ///< The alignment for the pool.
  119.   std::vector<MachineConstantPoolEntry> Constants; ///< The pool of constants.
  120.   /// MachineConstantPoolValues that use an existing MachineConstantPoolEntry.
  121.   DenseSet<MachineConstantPoolValue*> MachineCPVsSharingEntries;
  122.   const DataLayout &DL;
  123.  
  124.   const DataLayout &getDataLayout() const { return DL; }
  125.  
  126. public:
  127.   /// The only constructor.
  128.   explicit MachineConstantPool(const DataLayout &DL)
  129.       : PoolAlignment(1), DL(DL) {}
  130.   ~MachineConstantPool();
  131.  
  132.   /// Return the alignment required by the whole constant pool, of which the
  133.   /// first element must be aligned.
  134.   Align getConstantPoolAlign() const { return PoolAlignment; }
  135.  
  136.   /// getConstantPoolIndex - Create a new entry in the constant pool or return
  137.   /// an existing one.  User must specify the minimum required alignment for
  138.   /// the object.
  139.   unsigned getConstantPoolIndex(const Constant *C, Align Alignment);
  140.   unsigned getConstantPoolIndex(MachineConstantPoolValue *V, Align Alignment);
  141.  
  142.   /// isEmpty - Return true if this constant pool contains no constants.
  143.   bool isEmpty() const { return Constants.empty(); }
  144.  
  145.   const std::vector<MachineConstantPoolEntry> &getConstants() const {
  146.     return Constants;
  147.   }
  148.  
  149.   /// print - Used by the MachineFunction printer to print information about
  150.   /// constant pool objects.  Implemented in MachineFunction.cpp
  151.   void print(raw_ostream &OS) const;
  152.  
  153.   /// dump - Call print(cerr) to be called from the debugger.
  154.   void dump() const;
  155. };
  156.  
  157. } // end namespace llvm
  158.  
  159. #endif // LLVM_CODEGEN_MACHINECONSTANTPOOL_H
  160.