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