mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-06 09:54:49 +00:00
1. ConstantPoolSDNode alignment field is log2 value of the alignment requirement. This is not consistent with other SDNode variants. 2. MachineConstantPool alignment field is also a log2 value. 3. However, some places are creating ConstantPoolSDNode with alignment value rather than log2 values. This creates entries with artificially large alignments, e.g. 256 for SSE vector values. 4. Constant pool entry offsets are computed when they are created. However, asm printer group them by sections. That means the offsets are no longer valid. However, asm printer uses them to determine size of padding between entries. 5. Asm printer uses expensive data structure multimap to track constant pool entries by sections. 6. Asm printer iterate over SmallPtrSet when it's emitting constant pool entries. This is non-deterministic. Solutions: 1. ConstantPoolSDNode alignment field is changed to keep non-log2 value. 2. MachineConstantPool alignment field is also changed to keep non-log2 value. 3. Functions that create ConstantPool nodes are passing in non-log2 alignments. 4. MachineConstantPoolEntry no longer keeps an offset field. It's replaced with an alignment field. Offsets are not computed when constant pool entries are created. They are computed on the fly in asm printer and JIT. 5. Asm printer uses cheaper data structure to group constant pool entries. 6. Asm printer compute entry offsets after grouping is done. 7. Change JIT code to compute entry offsets on the fly. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@66875 91177308-0d34-0410-b5e6-96231b3b80d8
147 lines
4.6 KiB
C++
147 lines
4.6 KiB
C++
//===-- CodeGen/MachineConstantPool.h - Abstract Constant Pool --*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
/// @file
|
|
/// This file declares the MachineConstantPool class which is an abstract
|
|
/// constant pool to keep track of constants referenced by a function.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CODEGEN_MACHINECONSTANTPOOL_H
|
|
#define LLVM_CODEGEN_MACHINECONSTANTPOOL_H
|
|
|
|
#include <cassert>
|
|
#include <vector>
|
|
|
|
namespace llvm {
|
|
|
|
class Constant;
|
|
class FoldingSetNodeID;
|
|
class TargetData;
|
|
class TargetMachine;
|
|
class Type;
|
|
class MachineConstantPool;
|
|
class raw_ostream;
|
|
|
|
/// Abstract base class for all machine specific constantpool value subclasses.
|
|
///
|
|
class MachineConstantPoolValue {
|
|
const Type *Ty;
|
|
|
|
public:
|
|
explicit MachineConstantPoolValue(const Type *ty) : Ty(ty) {}
|
|
virtual ~MachineConstantPoolValue() {}
|
|
|
|
/// getType - get type of this MachineConstantPoolValue.
|
|
///
|
|
inline const Type *getType() const { return Ty; }
|
|
|
|
virtual int getExistingMachineCPValue(MachineConstantPool *CP,
|
|
unsigned Alignment) = 0;
|
|
|
|
virtual void AddSelectionDAGCSEId(FoldingSetNodeID &ID) = 0;
|
|
|
|
/// print - Implement operator<<
|
|
virtual void print(raw_ostream &O) const = 0;
|
|
};
|
|
|
|
inline raw_ostream &operator<<(raw_ostream &OS,
|
|
const MachineConstantPoolValue &V) {
|
|
V.print(OS);
|
|
return OS;
|
|
}
|
|
|
|
|
|
/// This class is a data container for one entry in a MachineConstantPool.
|
|
/// It contains a pointer to the value and an offset from the start of
|
|
/// the constant pool.
|
|
/// @brief An entry in a MachineConstantPool
|
|
class MachineConstantPoolEntry {
|
|
public:
|
|
/// The constant itself.
|
|
union {
|
|
Constant *ConstVal;
|
|
MachineConstantPoolValue *MachineCPVal;
|
|
} Val;
|
|
|
|
/// The required alignment for this entry. The top bit is set when Val is
|
|
/// a MachineConstantPoolValue.
|
|
unsigned Alignment;
|
|
|
|
MachineConstantPoolEntry(Constant *V, unsigned A)
|
|
: Alignment(A) {
|
|
Val.ConstVal = V;
|
|
}
|
|
MachineConstantPoolEntry(MachineConstantPoolValue *V, unsigned A)
|
|
: Alignment(A) {
|
|
Val.MachineCPVal = V;
|
|
Alignment |= 1 << (sizeof(unsigned)*8-1);
|
|
}
|
|
|
|
bool isMachineConstantPoolEntry() const {
|
|
return (int)Alignment < 0;
|
|
}
|
|
|
|
int getAlignment() const {
|
|
return Alignment & ~(1 << (sizeof(unsigned)*8-1));
|
|
}
|
|
|
|
const Type *getType() const;
|
|
};
|
|
|
|
/// The MachineConstantPool class keeps track of constants referenced by a
|
|
/// function which must be spilled to memory. This is used for constants which
|
|
/// are unable to be used directly as operands to instructions, which typically
|
|
/// include floating point and large integer constants.
|
|
///
|
|
/// Instructions reference the address of these constant pool constants through
|
|
/// the use of MO_ConstantPoolIndex values. When emitting assembly or machine
|
|
/// code, these virtual address references are converted to refer to the
|
|
/// address of the function constant pool values.
|
|
/// @brief The machine constant pool.
|
|
class MachineConstantPool {
|
|
const TargetData *TD; ///< The machine's TargetData.
|
|
unsigned PoolAlignment; ///< The alignment for the pool.
|
|
std::vector<MachineConstantPoolEntry> Constants; ///< The pool of constants.
|
|
public:
|
|
/// @brief The only constructor.
|
|
explicit MachineConstantPool(const TargetData *td)
|
|
: TD(td), PoolAlignment(1) {}
|
|
~MachineConstantPool();
|
|
|
|
/// getConstantPoolAlignment - Return the the alignment required by
|
|
/// the whole constant pool, of which the first element must be aligned.
|
|
unsigned getConstantPoolAlignment() const { return PoolAlignment; }
|
|
|
|
/// getConstantPoolIndex - Create a new entry in the constant pool or return
|
|
/// an existing one. User must specify the minimum required alignment for
|
|
/// the object.
|
|
unsigned getConstantPoolIndex(Constant *C, unsigned Alignment);
|
|
unsigned getConstantPoolIndex(MachineConstantPoolValue *V,unsigned Alignment);
|
|
|
|
/// isEmpty - Return true if this constant pool contains no constants.
|
|
bool isEmpty() const { return Constants.empty(); }
|
|
|
|
const std::vector<MachineConstantPoolEntry> &getConstants() const {
|
|
return Constants;
|
|
}
|
|
|
|
/// print - Used by the MachineFunction printer to print information about
|
|
/// constant pool objects. Implemented in MachineFunction.cpp
|
|
///
|
|
void print(raw_ostream &OS) const;
|
|
|
|
/// dump - Call print(cerr) to be called from the debugger.
|
|
void dump() const;
|
|
};
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|