Home | History | Annotate | Line # | Download | only in CodeGen 
      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