void JITEmitter::emitConstantPool(MachineConstantPool *MCP) { const std::vector<MachineConstantPoolEntry> &Constants = MCP->getConstants(); if (Constants.empty()) return; MachineConstantPoolEntry CPE = Constants.back(); unsigned Size = CPE.Offset; const Type *Ty = CPE.isMachineConstantPoolEntry() ? CPE.Val.MachineCPVal->getType() : CPE.Val.ConstVal->getType(); Size += TheJIT->getTargetData()->getABITypeSize(Ty); unsigned Align = 1 << MCP->getConstantPoolAlignment(); ConstantPoolBase = allocateSpace(Size, Align); ConstantPool = MCP; if (ConstantPoolBase == 0) return; // Buffer overflow. DOUT << "JIT: Emitted constant pool at [" << ConstantPoolBase << "] (size: " << Size << ", alignment: " << Align << ")\n"; // Initialize the memory for all of the constant pool entries. for (unsigned i = 0, e = Constants.size(); i != e; ++i) { void *CAddr = (char*)ConstantPoolBase+Constants[i].Offset; if (Constants[i].isMachineConstantPoolEntry()) { // FIXME: add support to lower machine constant pool values into bytes! cerr << "Initialize memory with machine specific constant pool entry" << " has not been implemented!\n"; abort(); } TheJIT->InitializeMemory(Constants[i].Val.ConstVal, CAddr); DOUT << "JIT: CP" << i << " at [" << CAddr << "]\n"; } }
/// EmitConstantPool - Print to the current output stream assembly /// representations of the constants in the constant pool MCP. This is /// used to print out constants which have been "spilled to memory" by /// the code generator. /// void AsmPrinter::EmitConstantPool(MachineConstantPool *MCP) { const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants(); if (CP.empty()) return; // Some targets require 4-, 8-, and 16- byte constant literals to be placed // in special sections. std::vector<std::pair<MachineConstantPoolEntry,unsigned> > FourByteCPs; std::vector<std::pair<MachineConstantPoolEntry,unsigned> > EightByteCPs; std::vector<std::pair<MachineConstantPoolEntry,unsigned> > SixteenByteCPs; std::vector<std::pair<MachineConstantPoolEntry,unsigned> > OtherCPs; std::vector<std::pair<MachineConstantPoolEntry,unsigned> > TargetCPs; for (unsigned i = 0, e = CP.size(); i != e; ++i) { MachineConstantPoolEntry CPE = CP[i]; const Type *Ty = CPE.getType(); if (TAI->getFourByteConstantSection() && TM.getTargetData()->getTypeSize(Ty) == 4) FourByteCPs.push_back(std::make_pair(CPE, i)); else if (TAI->getEightByteConstantSection() && TM.getTargetData()->getTypeSize(Ty) == 8) EightByteCPs.push_back(std::make_pair(CPE, i)); else if (TAI->getSixteenByteConstantSection() && TM.getTargetData()->getTypeSize(Ty) == 16) SixteenByteCPs.push_back(std::make_pair(CPE, i)); else OtherCPs.push_back(std::make_pair(CPE, i)); } unsigned Alignment = MCP->getConstantPoolAlignment(); EmitConstantPool(Alignment, TAI->getFourByteConstantSection(), FourByteCPs); EmitConstantPool(Alignment, TAI->getEightByteConstantSection(), EightByteCPs); EmitConstantPool(Alignment, TAI->getSixteenByteConstantSection(), SixteenByteCPs); EmitConstantPool(Alignment, TAI->getConstantPoolSection(), OtherCPs); }
static unsigned GetConstantPoolSizeInBytes(MachineConstantPool *MCP) { const std::vector<MachineConstantPoolEntry> &Constants = MCP->getConstants(); if (Constants.empty()) return 0; MachineConstantPoolEntry CPE = Constants.back(); unsigned Size = CPE.Offset; const Type *Ty = CPE.isMachineConstantPoolEntry() ? CPE.Val.MachineCPVal->getType() : CPE.Val.ConstVal->getType(); Size += TheJIT->getTargetData()->getABITypeSize(Ty); return Size; }
static unsigned GetConstantPoolSizeInBytes(MachineConstantPool *MCP, const DataLayout *TD) { const std::vector<MachineConstantPoolEntry> &Constants = MCP->getConstants(); if (Constants.empty()) return 0; unsigned Size = 0; for (unsigned i = 0, e = Constants.size(); i != e; ++i) { MachineConstantPoolEntry CPE = Constants[i]; unsigned AlignMask = CPE.getAlignment() - 1; Size = (Size + AlignMask) & ~AlignMask; Type *Ty = CPE.getType(); Size += TD->getTypeAllocSize(Ty); } return Size; }
void SVMBlockSizeAccumulator::AddConstant(const TargetData &TD, const MachineConstantPoolEntry &CPE) { AddConstant(TD.getTypeAllocSize(CPE.getType()), CPE.getAlignment()); }