]>
Commit | Line | Data |
---|---|---|
223e47cc LB |
1 | //===-- MachineFunction.cpp -----------------------------------------------===// |
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 | // Collect native machine code information for a function. This allows | |
11 | // target-specific information about the generated code to be stored with each | |
12 | // function. | |
13 | // | |
14 | //===----------------------------------------------------------------------===// | |
15 | ||
16 | #include "llvm/CodeGen/MachineFunction.h" | |
970d7e83 LB |
17 | #include "llvm/ADT/STLExtras.h" |
18 | #include "llvm/ADT/SmallString.h" | |
19 | #include "llvm/Analysis/ConstantFolding.h" | |
223e47cc | 20 | #include "llvm/CodeGen/MachineConstantPool.h" |
223e47cc | 21 | #include "llvm/CodeGen/MachineFrameInfo.h" |
970d7e83 | 22 | #include "llvm/CodeGen/MachineFunctionPass.h" |
223e47cc LB |
23 | #include "llvm/CodeGen/MachineInstr.h" |
24 | #include "llvm/CodeGen/MachineJumpTableInfo.h" | |
25 | #include "llvm/CodeGen/MachineModuleInfo.h" | |
26 | #include "llvm/CodeGen/MachineRegisterInfo.h" | |
27 | #include "llvm/CodeGen/Passes.h" | |
970d7e83 | 28 | #include "llvm/IR/DataLayout.h" |
1a4d82fc | 29 | #include "llvm/IR/DebugInfo.h" |
970d7e83 | 30 | #include "llvm/IR/Function.h" |
223e47cc LB |
31 | #include "llvm/MC/MCAsmInfo.h" |
32 | #include "llvm/MC/MCContext.h" | |
223e47cc | 33 | #include "llvm/Support/Debug.h" |
223e47cc LB |
34 | #include "llvm/Support/GraphWriter.h" |
35 | #include "llvm/Support/raw_ostream.h" | |
970d7e83 LB |
36 | #include "llvm/Target/TargetFrameLowering.h" |
37 | #include "llvm/Target/TargetLowering.h" | |
38 | #include "llvm/Target/TargetMachine.h" | |
1a4d82fc | 39 | #include "llvm/Target/TargetSubtargetInfo.h" |
223e47cc LB |
40 | using namespace llvm; |
41 | ||
1a4d82fc JJ |
42 | #define DEBUG_TYPE "codegen" |
43 | ||
223e47cc LB |
44 | //===----------------------------------------------------------------------===// |
45 | // MachineFunction implementation | |
46 | //===----------------------------------------------------------------------===// | |
47 | ||
48 | // Out of line virtual method. | |
49 | MachineFunctionInfo::~MachineFunctionInfo() {} | |
50 | ||
51 | void ilist_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) { | |
52 | MBB->getParent()->DeleteMachineBasicBlock(MBB); | |
53 | } | |
54 | ||
55 | MachineFunction::MachineFunction(const Function *F, const TargetMachine &TM, | |
85aaf69f | 56 | unsigned FunctionNum, MachineModuleInfo &mmi) |
1a4d82fc | 57 | : Fn(F), Target(TM), STI(TM.getSubtargetImpl()), Ctx(mmi.getContext()), |
85aaf69f SL |
58 | MMI(mmi) { |
59 | if (STI->getRegisterInfo()) | |
1a4d82fc | 60 | RegInfo = new (Allocator) MachineRegisterInfo(this); |
223e47cc | 61 | else |
1a4d82fc JJ |
62 | RegInfo = nullptr; |
63 | ||
64 | MFInfo = nullptr; | |
85aaf69f SL |
65 | FrameInfo = new (Allocator) |
66 | MachineFrameInfo(STI->getFrameLowering()->getStackAlignment(), | |
67 | STI->getFrameLowering()->isStackRealignable(), | |
68 | !F->hasFnAttribute("no-realign-stack")); | |
1a4d82fc | 69 | |
970d7e83 LB |
70 | if (Fn->getAttributes().hasAttribute(AttributeSet::FunctionIndex, |
71 | Attribute::StackAlignment)) | |
223e47cc | 72 | FrameInfo->ensureMaxAlignment(Fn->getAttributes(). |
970d7e83 | 73 | getStackAlignment(AttributeSet::FunctionIndex)); |
1a4d82fc JJ |
74 | |
75 | ConstantPool = new (Allocator) MachineConstantPool(TM); | |
85aaf69f | 76 | Alignment = STI->getTargetLowering()->getMinFunctionAlignment(); |
1a4d82fc | 77 | |
223e47cc | 78 | // FIXME: Shouldn't use pref alignment if explicit alignment is set on Fn. |
970d7e83 LB |
79 | if (!Fn->getAttributes().hasAttribute(AttributeSet::FunctionIndex, |
80 | Attribute::OptimizeForSize)) | |
85aaf69f SL |
81 | Alignment = std::max(Alignment, |
82 | STI->getTargetLowering()->getPrefFunctionAlignment()); | |
1a4d82fc | 83 | |
223e47cc | 84 | FunctionNumber = FunctionNum; |
1a4d82fc | 85 | JumpTableInfo = nullptr; |
223e47cc LB |
86 | } |
87 | ||
88 | MachineFunction::~MachineFunction() { | |
970d7e83 LB |
89 | // Don't call destructors on MachineInstr and MachineOperand. All of their |
90 | // memory comes from the BumpPtrAllocator which is about to be purged. | |
91 | // | |
92 | // Do call MachineBasicBlock destructors, it contains std::vectors. | |
93 | for (iterator I = begin(), E = end(); I != E; I = BasicBlocks.erase(I)) | |
94 | I->Insts.clearAndLeakNodesUnsafely(); | |
95 | ||
223e47cc | 96 | InstructionRecycler.clear(Allocator); |
970d7e83 | 97 | OperandRecycler.clear(Allocator); |
223e47cc LB |
98 | BasicBlockRecycler.clear(Allocator); |
99 | if (RegInfo) { | |
100 | RegInfo->~MachineRegisterInfo(); | |
101 | Allocator.Deallocate(RegInfo); | |
102 | } | |
103 | if (MFInfo) { | |
104 | MFInfo->~MachineFunctionInfo(); | |
105 | Allocator.Deallocate(MFInfo); | |
106 | } | |
107 | ||
108 | FrameInfo->~MachineFrameInfo(); | |
109 | Allocator.Deallocate(FrameInfo); | |
110 | ||
111 | ConstantPool->~MachineConstantPool(); | |
112 | Allocator.Deallocate(ConstantPool); | |
113 | ||
114 | if (JumpTableInfo) { | |
115 | JumpTableInfo->~MachineJumpTableInfo(); | |
116 | Allocator.Deallocate(JumpTableInfo); | |
117 | } | |
118 | } | |
119 | ||
120 | /// getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it | |
121 | /// does already exist, allocate one. | |
122 | MachineJumpTableInfo *MachineFunction:: | |
123 | getOrCreateJumpTableInfo(unsigned EntryKind) { | |
124 | if (JumpTableInfo) return JumpTableInfo; | |
125 | ||
126 | JumpTableInfo = new (Allocator) | |
127 | MachineJumpTableInfo((MachineJumpTableInfo::JTEntryKind)EntryKind); | |
128 | return JumpTableInfo; | |
129 | } | |
130 | ||
1a4d82fc JJ |
131 | /// Should we be emitting segmented stack stuff for the function |
132 | bool MachineFunction::shouldSplitStack() { | |
133 | return getFunction()->hasFnAttribute("split-stack"); | |
134 | } | |
135 | ||
223e47cc LB |
136 | /// RenumberBlocks - This discards all of the MachineBasicBlock numbers and |
137 | /// recomputes them. This guarantees that the MBB numbers are sequential, | |
138 | /// dense, and match the ordering of the blocks within the function. If a | |
139 | /// specific MachineBasicBlock is specified, only that block and those after | |
140 | /// it are renumbered. | |
141 | void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) { | |
142 | if (empty()) { MBBNumbering.clear(); return; } | |
143 | MachineFunction::iterator MBBI, E = end(); | |
1a4d82fc | 144 | if (MBB == nullptr) |
223e47cc LB |
145 | MBBI = begin(); |
146 | else | |
147 | MBBI = MBB; | |
148 | ||
149 | // Figure out the block number this should have. | |
150 | unsigned BlockNo = 0; | |
151 | if (MBBI != begin()) | |
1a4d82fc | 152 | BlockNo = std::prev(MBBI)->getNumber() + 1; |
223e47cc LB |
153 | |
154 | for (; MBBI != E; ++MBBI, ++BlockNo) { | |
155 | if (MBBI->getNumber() != (int)BlockNo) { | |
156 | // Remove use of the old number. | |
157 | if (MBBI->getNumber() != -1) { | |
158 | assert(MBBNumbering[MBBI->getNumber()] == &*MBBI && | |
159 | "MBB number mismatch!"); | |
1a4d82fc | 160 | MBBNumbering[MBBI->getNumber()] = nullptr; |
223e47cc LB |
161 | } |
162 | ||
163 | // If BlockNo is already taken, set that block's number to -1. | |
164 | if (MBBNumbering[BlockNo]) | |
165 | MBBNumbering[BlockNo]->setNumber(-1); | |
166 | ||
167 | MBBNumbering[BlockNo] = MBBI; | |
168 | MBBI->setNumber(BlockNo); | |
169 | } | |
170 | } | |
171 | ||
172 | // Okay, all the blocks are renumbered. If we have compactified the block | |
173 | // numbering, shrink MBBNumbering now. | |
174 | assert(BlockNo <= MBBNumbering.size() && "Mismatch!"); | |
175 | MBBNumbering.resize(BlockNo); | |
176 | } | |
177 | ||
178 | /// CreateMachineInstr - Allocate a new MachineInstr. Use this instead | |
179 | /// of `new MachineInstr'. | |
180 | /// | |
181 | MachineInstr * | |
182 | MachineFunction::CreateMachineInstr(const MCInstrDesc &MCID, | |
183 | DebugLoc DL, bool NoImp) { | |
184 | return new (InstructionRecycler.Allocate<MachineInstr>(Allocator)) | |
970d7e83 | 185 | MachineInstr(*this, MCID, DL, NoImp); |
223e47cc LB |
186 | } |
187 | ||
188 | /// CloneMachineInstr - Create a new MachineInstr which is a copy of the | |
189 | /// 'Orig' instruction, identical in all ways except the instruction | |
190 | /// has no parent, prev, or next. | |
191 | /// | |
192 | MachineInstr * | |
193 | MachineFunction::CloneMachineInstr(const MachineInstr *Orig) { | |
194 | return new (InstructionRecycler.Allocate<MachineInstr>(Allocator)) | |
195 | MachineInstr(*this, *Orig); | |
196 | } | |
197 | ||
198 | /// DeleteMachineInstr - Delete the given MachineInstr. | |
199 | /// | |
970d7e83 LB |
200 | /// This function also serves as the MachineInstr destructor - the real |
201 | /// ~MachineInstr() destructor must be empty. | |
223e47cc LB |
202 | void |
203 | MachineFunction::DeleteMachineInstr(MachineInstr *MI) { | |
970d7e83 LB |
204 | // Strip it for parts. The operand array and the MI object itself are |
205 | // independently recyclable. | |
206 | if (MI->Operands) | |
207 | deallocateOperandArray(MI->CapOperands, MI->Operands); | |
208 | // Don't call ~MachineInstr() which must be trivial anyway because | |
209 | // ~MachineFunction drops whole lists of MachineInstrs wihout calling their | |
210 | // destructors. | |
223e47cc LB |
211 | InstructionRecycler.Deallocate(Allocator, MI); |
212 | } | |
213 | ||
214 | /// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this | |
215 | /// instead of `new MachineBasicBlock'. | |
216 | /// | |
217 | MachineBasicBlock * | |
218 | MachineFunction::CreateMachineBasicBlock(const BasicBlock *bb) { | |
219 | return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator)) | |
220 | MachineBasicBlock(*this, bb); | |
221 | } | |
222 | ||
223 | /// DeleteMachineBasicBlock - Delete the given MachineBasicBlock. | |
224 | /// | |
225 | void | |
226 | MachineFunction::DeleteMachineBasicBlock(MachineBasicBlock *MBB) { | |
227 | assert(MBB->getParent() == this && "MBB parent mismatch!"); | |
228 | MBB->~MachineBasicBlock(); | |
229 | BasicBlockRecycler.Deallocate(Allocator, MBB); | |
230 | } | |
231 | ||
232 | MachineMemOperand * | |
233 | MachineFunction::getMachineMemOperand(MachinePointerInfo PtrInfo, unsigned f, | |
234 | uint64_t s, unsigned base_alignment, | |
1a4d82fc | 235 | const AAMDNodes &AAInfo, |
223e47cc LB |
236 | const MDNode *Ranges) { |
237 | return new (Allocator) MachineMemOperand(PtrInfo, f, s, base_alignment, | |
1a4d82fc | 238 | AAInfo, Ranges); |
223e47cc LB |
239 | } |
240 | ||
241 | MachineMemOperand * | |
242 | MachineFunction::getMachineMemOperand(const MachineMemOperand *MMO, | |
243 | int64_t Offset, uint64_t Size) { | |
1a4d82fc JJ |
244 | if (MMO->getValue()) |
245 | return new (Allocator) | |
246 | MachineMemOperand(MachinePointerInfo(MMO->getValue(), | |
247 | MMO->getOffset()+Offset), | |
248 | MMO->getFlags(), Size, | |
85aaf69f | 249 | MMO->getBaseAlignment()); |
223e47cc | 250 | return new (Allocator) |
1a4d82fc | 251 | MachineMemOperand(MachinePointerInfo(MMO->getPseudoValue(), |
223e47cc LB |
252 | MMO->getOffset()+Offset), |
253 | MMO->getFlags(), Size, | |
85aaf69f | 254 | MMO->getBaseAlignment()); |
223e47cc LB |
255 | } |
256 | ||
257 | MachineInstr::mmo_iterator | |
258 | MachineFunction::allocateMemRefsArray(unsigned long Num) { | |
259 | return Allocator.Allocate<MachineMemOperand *>(Num); | |
260 | } | |
261 | ||
262 | std::pair<MachineInstr::mmo_iterator, MachineInstr::mmo_iterator> | |
263 | MachineFunction::extractLoadMemRefs(MachineInstr::mmo_iterator Begin, | |
264 | MachineInstr::mmo_iterator End) { | |
265 | // Count the number of load mem refs. | |
266 | unsigned Num = 0; | |
267 | for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) | |
268 | if ((*I)->isLoad()) | |
269 | ++Num; | |
270 | ||
271 | // Allocate a new array and populate it with the load information. | |
272 | MachineInstr::mmo_iterator Result = allocateMemRefsArray(Num); | |
273 | unsigned Index = 0; | |
274 | for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) { | |
275 | if ((*I)->isLoad()) { | |
276 | if (!(*I)->isStore()) | |
277 | // Reuse the MMO. | |
278 | Result[Index] = *I; | |
279 | else { | |
280 | // Clone the MMO and unset the store flag. | |
281 | MachineMemOperand *JustLoad = | |
282 | getMachineMemOperand((*I)->getPointerInfo(), | |
283 | (*I)->getFlags() & ~MachineMemOperand::MOStore, | |
284 | (*I)->getSize(), (*I)->getBaseAlignment(), | |
1a4d82fc | 285 | (*I)->getAAInfo()); |
223e47cc LB |
286 | Result[Index] = JustLoad; |
287 | } | |
288 | ++Index; | |
289 | } | |
290 | } | |
291 | return std::make_pair(Result, Result + Num); | |
292 | } | |
293 | ||
294 | std::pair<MachineInstr::mmo_iterator, MachineInstr::mmo_iterator> | |
295 | MachineFunction::extractStoreMemRefs(MachineInstr::mmo_iterator Begin, | |
296 | MachineInstr::mmo_iterator End) { | |
297 | // Count the number of load mem refs. | |
298 | unsigned Num = 0; | |
299 | for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) | |
300 | if ((*I)->isStore()) | |
301 | ++Num; | |
302 | ||
303 | // Allocate a new array and populate it with the store information. | |
304 | MachineInstr::mmo_iterator Result = allocateMemRefsArray(Num); | |
305 | unsigned Index = 0; | |
306 | for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) { | |
307 | if ((*I)->isStore()) { | |
308 | if (!(*I)->isLoad()) | |
309 | // Reuse the MMO. | |
310 | Result[Index] = *I; | |
311 | else { | |
312 | // Clone the MMO and unset the load flag. | |
313 | MachineMemOperand *JustStore = | |
314 | getMachineMemOperand((*I)->getPointerInfo(), | |
315 | (*I)->getFlags() & ~MachineMemOperand::MOLoad, | |
316 | (*I)->getSize(), (*I)->getBaseAlignment(), | |
1a4d82fc | 317 | (*I)->getAAInfo()); |
223e47cc LB |
318 | Result[Index] = JustStore; |
319 | } | |
320 | ++Index; | |
321 | } | |
322 | } | |
323 | return std::make_pair(Result, Result + Num); | |
324 | } | |
325 | ||
326 | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) | |
327 | void MachineFunction::dump() const { | |
328 | print(dbgs()); | |
329 | } | |
330 | #endif | |
331 | ||
332 | StringRef MachineFunction::getName() const { | |
333 | assert(getFunction() && "No function!"); | |
334 | return getFunction()->getName(); | |
335 | } | |
336 | ||
337 | void MachineFunction::print(raw_ostream &OS, SlotIndexes *Indexes) const { | |
338 | OS << "# Machine code for function " << getName() << ": "; | |
339 | if (RegInfo) { | |
340 | OS << (RegInfo->isSSA() ? "SSA" : "Post SSA"); | |
341 | if (!RegInfo->tracksLiveness()) | |
342 | OS << ", not tracking liveness"; | |
343 | } | |
344 | OS << '\n'; | |
345 | ||
346 | // Print Frame Information | |
347 | FrameInfo->print(*this, OS); | |
348 | ||
349 | // Print JumpTable Information | |
350 | if (JumpTableInfo) | |
351 | JumpTableInfo->print(OS); | |
352 | ||
353 | // Print Constant Pool | |
354 | ConstantPool->print(OS); | |
355 | ||
1a4d82fc | 356 | const TargetRegisterInfo *TRI = getSubtarget().getRegisterInfo(); |
223e47cc LB |
357 | |
358 | if (RegInfo && !RegInfo->livein_empty()) { | |
359 | OS << "Function Live Ins: "; | |
360 | for (MachineRegisterInfo::livein_iterator | |
361 | I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) { | |
362 | OS << PrintReg(I->first, TRI); | |
363 | if (I->second) | |
364 | OS << " in " << PrintReg(I->second, TRI); | |
1a4d82fc | 365 | if (std::next(I) != E) |
223e47cc LB |
366 | OS << ", "; |
367 | } | |
368 | OS << '\n'; | |
369 | } | |
223e47cc | 370 | |
1a4d82fc | 371 | for (const auto &BB : *this) { |
223e47cc | 372 | OS << '\n'; |
1a4d82fc | 373 | BB.print(OS, Indexes); |
223e47cc LB |
374 | } |
375 | ||
376 | OS << "\n# End machine code for function " << getName() << ".\n\n"; | |
377 | } | |
378 | ||
379 | namespace llvm { | |
380 | template<> | |
381 | struct DOTGraphTraits<const MachineFunction*> : public DefaultDOTGraphTraits { | |
382 | ||
383 | DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {} | |
384 | ||
385 | static std::string getGraphName(const MachineFunction *F) { | |
386 | return "CFG for '" + F->getName().str() + "' function"; | |
387 | } | |
388 | ||
389 | std::string getNodeLabel(const MachineBasicBlock *Node, | |
390 | const MachineFunction *Graph) { | |
391 | std::string OutStr; | |
392 | { | |
393 | raw_string_ostream OSS(OutStr); | |
394 | ||
395 | if (isSimple()) { | |
396 | OSS << "BB#" << Node->getNumber(); | |
397 | if (const BasicBlock *BB = Node->getBasicBlock()) | |
398 | OSS << ": " << BB->getName(); | |
399 | } else | |
400 | Node->print(OSS); | |
401 | } | |
402 | ||
403 | if (OutStr[0] == '\n') OutStr.erase(OutStr.begin()); | |
404 | ||
405 | // Process string output to make it nicer... | |
406 | for (unsigned i = 0; i != OutStr.length(); ++i) | |
407 | if (OutStr[i] == '\n') { // Left justify | |
408 | OutStr[i] = '\\'; | |
409 | OutStr.insert(OutStr.begin()+i+1, 'l'); | |
410 | } | |
411 | return OutStr; | |
412 | } | |
413 | }; | |
414 | } | |
415 | ||
416 | void MachineFunction::viewCFG() const | |
417 | { | |
418 | #ifndef NDEBUG | |
419 | ViewGraph(this, "mf" + getName()); | |
420 | #else | |
421 | errs() << "MachineFunction::viewCFG is only available in debug builds on " | |
422 | << "systems with Graphviz or gv!\n"; | |
423 | #endif // NDEBUG | |
424 | } | |
425 | ||
426 | void MachineFunction::viewCFGOnly() const | |
427 | { | |
428 | #ifndef NDEBUG | |
429 | ViewGraph(this, "mf" + getName(), true); | |
430 | #else | |
431 | errs() << "MachineFunction::viewCFGOnly is only available in debug builds on " | |
432 | << "systems with Graphviz or gv!\n"; | |
433 | #endif // NDEBUG | |
434 | } | |
435 | ||
436 | /// addLiveIn - Add the specified physical register as a live-in value and | |
437 | /// create a corresponding virtual register for it. | |
438 | unsigned MachineFunction::addLiveIn(unsigned PReg, | |
439 | const TargetRegisterClass *RC) { | |
440 | MachineRegisterInfo &MRI = getRegInfo(); | |
441 | unsigned VReg = MRI.getLiveInVirtReg(PReg); | |
442 | if (VReg) { | |
1a4d82fc JJ |
443 | const TargetRegisterClass *VRegRC = MRI.getRegClass(VReg); |
444 | (void)VRegRC; | |
445 | // A physical register can be added several times. | |
446 | // Between two calls, the register class of the related virtual register | |
447 | // may have been constrained to match some operation constraints. | |
448 | // In that case, check that the current register class includes the | |
449 | // physical register and is a sub class of the specified RC. | |
450 | assert((VRegRC == RC || (VRegRC->contains(PReg) && | |
451 | RC->hasSubClassEq(VRegRC))) && | |
452 | "Register class mismatch!"); | |
223e47cc LB |
453 | return VReg; |
454 | } | |
455 | VReg = MRI.createVirtualRegister(RC); | |
456 | MRI.addLiveIn(PReg, VReg); | |
457 | return VReg; | |
458 | } | |
459 | ||
460 | /// getJTISymbol - Return the MCSymbol for the specified non-empty jump table. | |
461 | /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a | |
462 | /// normal 'L' label is returned. | |
1a4d82fc | 463 | MCSymbol *MachineFunction::getJTISymbol(unsigned JTI, MCContext &Ctx, |
223e47cc | 464 | bool isLinkerPrivate) const { |
1a4d82fc | 465 | const DataLayout *DL = getSubtarget().getDataLayout(); |
223e47cc LB |
466 | assert(JumpTableInfo && "No jump tables"); |
467 | assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!"); | |
223e47cc | 468 | |
1a4d82fc JJ |
469 | const char *Prefix = isLinkerPrivate ? DL->getLinkerPrivateGlobalPrefix() : |
470 | DL->getPrivateGlobalPrefix(); | |
223e47cc LB |
471 | SmallString<60> Name; |
472 | raw_svector_ostream(Name) | |
473 | << Prefix << "JTI" << getFunctionNumber() << '_' << JTI; | |
474 | return Ctx.GetOrCreateSymbol(Name.str()); | |
475 | } | |
476 | ||
477 | /// getPICBaseSymbol - Return a function-local symbol to represent the PIC | |
478 | /// base. | |
479 | MCSymbol *MachineFunction::getPICBaseSymbol() const { | |
1a4d82fc JJ |
480 | const DataLayout *DL = getSubtarget().getDataLayout(); |
481 | return Ctx.GetOrCreateSymbol(Twine(DL->getPrivateGlobalPrefix())+ | |
223e47cc LB |
482 | Twine(getFunctionNumber())+"$pb"); |
483 | } | |
484 | ||
485 | //===----------------------------------------------------------------------===// | |
486 | // MachineFrameInfo implementation | |
487 | //===----------------------------------------------------------------------===// | |
488 | ||
970d7e83 LB |
489 | /// ensureMaxAlignment - Make sure the function is at least Align bytes |
490 | /// aligned. | |
491 | void MachineFrameInfo::ensureMaxAlignment(unsigned Align) { | |
85aaf69f SL |
492 | if (!StackRealignable || !RealignOption) |
493 | assert(Align <= StackAlignment && | |
970d7e83 LB |
494 | "For targets without stack realignment, Align is out of limit!"); |
495 | if (MaxAlignment < Align) MaxAlignment = Align; | |
496 | } | |
497 | ||
498 | /// clampStackAlignment - Clamp the alignment if requested and emit a warning. | |
499 | static inline unsigned clampStackAlignment(bool ShouldClamp, unsigned Align, | |
500 | unsigned StackAlign) { | |
501 | if (!ShouldClamp || Align <= StackAlign) | |
502 | return Align; | |
503 | DEBUG(dbgs() << "Warning: requested alignment " << Align | |
504 | << " exceeds the stack alignment " << StackAlign | |
505 | << " when stack realignment is off" << '\n'); | |
506 | return StackAlign; | |
507 | } | |
508 | ||
509 | /// CreateStackObject - Create a new statically sized stack object, returning | |
510 | /// a nonnegative identifier to represent it. | |
511 | /// | |
512 | int MachineFrameInfo::CreateStackObject(uint64_t Size, unsigned Alignment, | |
1a4d82fc | 513 | bool isSS, const AllocaInst *Alloca) { |
970d7e83 | 514 | assert(Size != 0 && "Cannot allocate zero size stack objects!"); |
85aaf69f SL |
515 | Alignment = clampStackAlignment(!StackRealignable || !RealignOption, |
516 | Alignment, StackAlignment); | |
1a4d82fc JJ |
517 | Objects.push_back(StackObject(Size, Alignment, 0, false, isSS, Alloca, |
518 | !isSS)); | |
970d7e83 LB |
519 | int Index = (int)Objects.size() - NumFixedObjects - 1; |
520 | assert(Index >= 0 && "Bad frame index!"); | |
521 | ensureMaxAlignment(Alignment); | |
522 | return Index; | |
523 | } | |
524 | ||
525 | /// CreateSpillStackObject - Create a new statically sized stack object that | |
526 | /// represents a spill slot, returning a nonnegative identifier to represent | |
527 | /// it. | |
528 | /// | |
529 | int MachineFrameInfo::CreateSpillStackObject(uint64_t Size, | |
530 | unsigned Alignment) { | |
85aaf69f SL |
531 | Alignment = clampStackAlignment(!StackRealignable || !RealignOption, |
532 | Alignment, StackAlignment); | |
1a4d82fc | 533 | CreateStackObject(Size, Alignment, true); |
970d7e83 LB |
534 | int Index = (int)Objects.size() - NumFixedObjects - 1; |
535 | ensureMaxAlignment(Alignment); | |
536 | return Index; | |
537 | } | |
538 | ||
539 | /// CreateVariableSizedObject - Notify the MachineFrameInfo object that a | |
540 | /// variable sized object has been created. This must be created whenever a | |
541 | /// variable sized object is created, whether or not the index returned is | |
542 | /// actually used. | |
543 | /// | |
1a4d82fc JJ |
544 | int MachineFrameInfo::CreateVariableSizedObject(unsigned Alignment, |
545 | const AllocaInst *Alloca) { | |
970d7e83 | 546 | HasVarSizedObjects = true; |
85aaf69f SL |
547 | Alignment = clampStackAlignment(!StackRealignable || !RealignOption, |
548 | Alignment, StackAlignment); | |
1a4d82fc | 549 | Objects.push_back(StackObject(0, Alignment, 0, false, false, Alloca, true)); |
970d7e83 LB |
550 | ensureMaxAlignment(Alignment); |
551 | return (int)Objects.size()-NumFixedObjects-1; | |
552 | } | |
553 | ||
223e47cc LB |
554 | /// CreateFixedObject - Create a new object at a fixed location on the stack. |
555 | /// All fixed objects should be created before other objects are created for | |
556 | /// efficiency. By default, fixed objects are immutable. This returns an | |
557 | /// index with a negative value. | |
558 | /// | |
559 | int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset, | |
1a4d82fc | 560 | bool Immutable, bool isAliased) { |
223e47cc LB |
561 | assert(Size != 0 && "Cannot allocate zero size fixed stack objects!"); |
562 | // The alignment of the frame index can be determined from its offset from | |
563 | // the incoming frame position. If the frame object is at offset 32 and | |
564 | // the stack is guaranteed to be 16-byte aligned, then we know that the | |
565 | // object is 16-byte aligned. | |
85aaf69f SL |
566 | unsigned Align = MinAlign(SPOffset, StackAlignment); |
567 | Align = clampStackAlignment(!StackRealignable || !RealignOption, Align, | |
568 | StackAlignment); | |
223e47cc LB |
569 | Objects.insert(Objects.begin(), StackObject(Size, Align, SPOffset, Immutable, |
570 | /*isSS*/ false, | |
1a4d82fc | 571 | /*Alloca*/ nullptr, isAliased)); |
223e47cc LB |
572 | return -++NumFixedObjects; |
573 | } | |
574 | ||
1a4d82fc JJ |
575 | /// CreateFixedSpillStackObject - Create a spill slot at a fixed location |
576 | /// on the stack. Returns an index with a negative value. | |
577 | int MachineFrameInfo::CreateFixedSpillStackObject(uint64_t Size, | |
578 | int64_t SPOffset) { | |
85aaf69f SL |
579 | unsigned Align = MinAlign(SPOffset, StackAlignment); |
580 | Align = clampStackAlignment(!StackRealignable || !RealignOption, Align, | |
581 | StackAlignment); | |
1a4d82fc JJ |
582 | Objects.insert(Objects.begin(), StackObject(Size, Align, SPOffset, |
583 | /*Immutable*/ true, | |
584 | /*isSS*/ true, | |
585 | /*Alloca*/ nullptr, | |
586 | /*isAliased*/ false)); | |
587 | return -++NumFixedObjects; | |
588 | } | |
223e47cc | 589 | |
85aaf69f SL |
590 | int MachineFrameInfo::CreateFrameAllocation(uint64_t Size) { |
591 | // Force the use of a frame pointer. The intention is that this intrinsic be | |
592 | // used in conjunction with unwind mechanisms that leak the frame pointer. | |
593 | setFrameAddressIsTaken(true); | |
594 | Size = RoundUpToAlignment(Size, StackAlignment); | |
595 | return CreateStackObject(Size, StackAlignment, false); | |
596 | } | |
597 | ||
223e47cc LB |
598 | BitVector |
599 | MachineFrameInfo::getPristineRegs(const MachineBasicBlock *MBB) const { | |
600 | assert(MBB && "MBB must be valid"); | |
601 | const MachineFunction *MF = MBB->getParent(); | |
602 | assert(MF && "MBB must be part of a MachineFunction"); | |
603 | const TargetMachine &TM = MF->getTarget(); | |
1a4d82fc | 604 | const TargetRegisterInfo *TRI = TM.getSubtargetImpl()->getRegisterInfo(); |
223e47cc LB |
605 | BitVector BV(TRI->getNumRegs()); |
606 | ||
607 | // Before CSI is calculated, no registers are considered pristine. They can be | |
608 | // freely used and PEI will make sure they are saved. | |
609 | if (!isCalleeSavedInfoValid()) | |
610 | return BV; | |
611 | ||
1a4d82fc | 612 | for (const MCPhysReg *CSR = TRI->getCalleeSavedRegs(MF); CSR && *CSR; ++CSR) |
223e47cc LB |
613 | BV.set(*CSR); |
614 | ||
615 | // The entry MBB always has all CSRs pristine. | |
616 | if (MBB == &MF->front()) | |
617 | return BV; | |
618 | ||
619 | // On other MBBs the saved CSRs are not pristine. | |
620 | const std::vector<CalleeSavedInfo> &CSI = getCalleeSavedInfo(); | |
621 | for (std::vector<CalleeSavedInfo>::const_iterator I = CSI.begin(), | |
622 | E = CSI.end(); I != E; ++I) | |
623 | BV.reset(I->getReg()); | |
624 | ||
625 | return BV; | |
626 | } | |
627 | ||
970d7e83 | 628 | unsigned MachineFrameInfo::estimateStackSize(const MachineFunction &MF) const { |
1a4d82fc JJ |
629 | const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering(); |
630 | const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo(); | |
970d7e83 LB |
631 | unsigned MaxAlign = getMaxAlignment(); |
632 | int Offset = 0; | |
633 | ||
634 | // This code is very, very similar to PEI::calculateFrameObjectOffsets(). | |
635 | // It really should be refactored to share code. Until then, changes | |
636 | // should keep in mind that there's tight coupling between the two. | |
637 | ||
638 | for (int i = getObjectIndexBegin(); i != 0; ++i) { | |
639 | int FixedOff = -getObjectOffset(i); | |
640 | if (FixedOff > Offset) Offset = FixedOff; | |
641 | } | |
642 | for (unsigned i = 0, e = getObjectIndexEnd(); i != e; ++i) { | |
643 | if (isDeadObjectIndex(i)) | |
644 | continue; | |
645 | Offset += getObjectSize(i); | |
646 | unsigned Align = getObjectAlignment(i); | |
647 | // Adjust to alignment boundary | |
648 | Offset = (Offset+Align-1)/Align*Align; | |
649 | ||
650 | MaxAlign = std::max(Align, MaxAlign); | |
651 | } | |
652 | ||
653 | if (adjustsStack() && TFI->hasReservedCallFrame(MF)) | |
654 | Offset += getMaxCallFrameSize(); | |
655 | ||
656 | // Round up the size to a multiple of the alignment. If the function has | |
657 | // any calls or alloca's, align to the target's StackAlignment value to | |
658 | // ensure that the callee's frame or the alloca data is suitably aligned; | |
659 | // otherwise, for leaf functions, align to the TransientStackAlignment | |
660 | // value. | |
661 | unsigned StackAlign; | |
662 | if (adjustsStack() || hasVarSizedObjects() || | |
663 | (RegInfo->needsStackRealignment(MF) && getObjectIndexEnd() != 0)) | |
664 | StackAlign = TFI->getStackAlignment(); | |
665 | else | |
666 | StackAlign = TFI->getTransientStackAlignment(); | |
667 | ||
668 | // If the frame pointer is eliminated, all frame offsets will be relative to | |
669 | // SP not FP. Align to MaxAlign so this works. | |
670 | StackAlign = std::max(StackAlign, MaxAlign); | |
671 | unsigned AlignMask = StackAlign - 1; | |
672 | Offset = (Offset + AlignMask) & ~uint64_t(AlignMask); | |
673 | ||
674 | return (unsigned)Offset; | |
675 | } | |
223e47cc LB |
676 | |
677 | void MachineFrameInfo::print(const MachineFunction &MF, raw_ostream &OS) const{ | |
678 | if (Objects.empty()) return; | |
679 | ||
1a4d82fc | 680 | const TargetFrameLowering *FI = MF.getSubtarget().getFrameLowering(); |
223e47cc LB |
681 | int ValOffset = (FI ? FI->getOffsetOfLocalArea() : 0); |
682 | ||
683 | OS << "Frame Objects:\n"; | |
684 | ||
685 | for (unsigned i = 0, e = Objects.size(); i != e; ++i) { | |
686 | const StackObject &SO = Objects[i]; | |
687 | OS << " fi#" << (int)(i-NumFixedObjects) << ": "; | |
688 | if (SO.Size == ~0ULL) { | |
689 | OS << "dead\n"; | |
690 | continue; | |
691 | } | |
692 | if (SO.Size == 0) | |
693 | OS << "variable sized"; | |
694 | else | |
695 | OS << "size=" << SO.Size; | |
696 | OS << ", align=" << SO.Alignment; | |
697 | ||
698 | if (i < NumFixedObjects) | |
699 | OS << ", fixed"; | |
700 | if (i < NumFixedObjects || SO.SPOffset != -1) { | |
701 | int64_t Off = SO.SPOffset - ValOffset; | |
702 | OS << ", at location [SP"; | |
703 | if (Off > 0) | |
704 | OS << "+" << Off; | |
705 | else if (Off < 0) | |
706 | OS << Off; | |
707 | OS << "]"; | |
708 | } | |
709 | OS << "\n"; | |
710 | } | |
711 | } | |
712 | ||
713 | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) | |
714 | void MachineFrameInfo::dump(const MachineFunction &MF) const { | |
715 | print(MF, dbgs()); | |
716 | } | |
717 | #endif | |
718 | ||
719 | //===----------------------------------------------------------------------===// | |
720 | // MachineJumpTableInfo implementation | |
721 | //===----------------------------------------------------------------------===// | |
722 | ||
723 | /// getEntrySize - Return the size of each entry in the jump table. | |
970d7e83 | 724 | unsigned MachineJumpTableInfo::getEntrySize(const DataLayout &TD) const { |
223e47cc LB |
725 | // The size of a jump table entry is 4 bytes unless the entry is just the |
726 | // address of a block, in which case it is the pointer size. | |
727 | switch (getEntryKind()) { | |
728 | case MachineJumpTableInfo::EK_BlockAddress: | |
729 | return TD.getPointerSize(); | |
730 | case MachineJumpTableInfo::EK_GPRel64BlockAddress: | |
731 | return 8; | |
732 | case MachineJumpTableInfo::EK_GPRel32BlockAddress: | |
733 | case MachineJumpTableInfo::EK_LabelDifference32: | |
734 | case MachineJumpTableInfo::EK_Custom32: | |
735 | return 4; | |
736 | case MachineJumpTableInfo::EK_Inline: | |
737 | return 0; | |
738 | } | |
739 | llvm_unreachable("Unknown jump table encoding!"); | |
740 | } | |
741 | ||
742 | /// getEntryAlignment - Return the alignment of each entry in the jump table. | |
970d7e83 | 743 | unsigned MachineJumpTableInfo::getEntryAlignment(const DataLayout &TD) const { |
223e47cc LB |
744 | // The alignment of a jump table entry is the alignment of int32 unless the |
745 | // entry is just the address of a block, in which case it is the pointer | |
746 | // alignment. | |
747 | switch (getEntryKind()) { | |
748 | case MachineJumpTableInfo::EK_BlockAddress: | |
749 | return TD.getPointerABIAlignment(); | |
750 | case MachineJumpTableInfo::EK_GPRel64BlockAddress: | |
751 | return TD.getABIIntegerTypeAlignment(64); | |
752 | case MachineJumpTableInfo::EK_GPRel32BlockAddress: | |
753 | case MachineJumpTableInfo::EK_LabelDifference32: | |
754 | case MachineJumpTableInfo::EK_Custom32: | |
755 | return TD.getABIIntegerTypeAlignment(32); | |
756 | case MachineJumpTableInfo::EK_Inline: | |
757 | return 1; | |
758 | } | |
759 | llvm_unreachable("Unknown jump table encoding!"); | |
760 | } | |
761 | ||
762 | /// createJumpTableIndex - Create a new jump table entry in the jump table info. | |
763 | /// | |
764 | unsigned MachineJumpTableInfo::createJumpTableIndex( | |
765 | const std::vector<MachineBasicBlock*> &DestBBs) { | |
766 | assert(!DestBBs.empty() && "Cannot create an empty jump table!"); | |
767 | JumpTables.push_back(MachineJumpTableEntry(DestBBs)); | |
768 | return JumpTables.size()-1; | |
769 | } | |
770 | ||
771 | /// ReplaceMBBInJumpTables - If Old is the target of any jump tables, update | |
772 | /// the jump tables to branch to New instead. | |
773 | bool MachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old, | |
774 | MachineBasicBlock *New) { | |
775 | assert(Old != New && "Not making a change?"); | |
776 | bool MadeChange = false; | |
777 | for (size_t i = 0, e = JumpTables.size(); i != e; ++i) | |
778 | ReplaceMBBInJumpTable(i, Old, New); | |
779 | return MadeChange; | |
780 | } | |
781 | ||
782 | /// ReplaceMBBInJumpTable - If Old is a target of the jump tables, update | |
783 | /// the jump table to branch to New instead. | |
784 | bool MachineJumpTableInfo::ReplaceMBBInJumpTable(unsigned Idx, | |
785 | MachineBasicBlock *Old, | |
786 | MachineBasicBlock *New) { | |
787 | assert(Old != New && "Not making a change?"); | |
788 | bool MadeChange = false; | |
789 | MachineJumpTableEntry &JTE = JumpTables[Idx]; | |
790 | for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j) | |
791 | if (JTE.MBBs[j] == Old) { | |
792 | JTE.MBBs[j] = New; | |
793 | MadeChange = true; | |
794 | } | |
795 | return MadeChange; | |
796 | } | |
797 | ||
798 | void MachineJumpTableInfo::print(raw_ostream &OS) const { | |
799 | if (JumpTables.empty()) return; | |
800 | ||
801 | OS << "Jump Tables:\n"; | |
802 | ||
803 | for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) { | |
804 | OS << " jt#" << i << ": "; | |
805 | for (unsigned j = 0, f = JumpTables[i].MBBs.size(); j != f; ++j) | |
806 | OS << " BB#" << JumpTables[i].MBBs[j]->getNumber(); | |
807 | } | |
808 | ||
809 | OS << '\n'; | |
810 | } | |
811 | ||
812 | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) | |
813 | void MachineJumpTableInfo::dump() const { print(dbgs()); } | |
814 | #endif | |
815 | ||
816 | ||
817 | //===----------------------------------------------------------------------===// | |
818 | // MachineConstantPool implementation | |
819 | //===----------------------------------------------------------------------===// | |
820 | ||
821 | void MachineConstantPoolValue::anchor() { } | |
822 | ||
1a4d82fc JJ |
823 | const DataLayout *MachineConstantPool::getDataLayout() const { |
824 | return TM.getSubtargetImpl()->getDataLayout(); | |
825 | } | |
826 | ||
223e47cc LB |
827 | Type *MachineConstantPoolEntry::getType() const { |
828 | if (isMachineConstantPoolEntry()) | |
829 | return Val.MachineCPVal->getType(); | |
830 | return Val.ConstVal->getType(); | |
831 | } | |
832 | ||
833 | ||
834 | unsigned MachineConstantPoolEntry::getRelocationInfo() const { | |
835 | if (isMachineConstantPoolEntry()) | |
836 | return Val.MachineCPVal->getRelocationInfo(); | |
837 | return Val.ConstVal->getRelocationInfo(); | |
838 | } | |
839 | ||
1a4d82fc JJ |
840 | SectionKind |
841 | MachineConstantPoolEntry::getSectionKind(const DataLayout *DL) const { | |
842 | SectionKind Kind; | |
843 | switch (getRelocationInfo()) { | |
844 | default: | |
845 | llvm_unreachable("Unknown section kind"); | |
846 | case 2: | |
847 | Kind = SectionKind::getReadOnlyWithRel(); | |
848 | break; | |
849 | case 1: | |
850 | Kind = SectionKind::getReadOnlyWithRelLocal(); | |
851 | break; | |
852 | case 0: | |
853 | switch (DL->getTypeAllocSize(getType())) { | |
854 | case 4: | |
855 | Kind = SectionKind::getMergeableConst4(); | |
856 | break; | |
857 | case 8: | |
858 | Kind = SectionKind::getMergeableConst8(); | |
859 | break; | |
860 | case 16: | |
861 | Kind = SectionKind::getMergeableConst16(); | |
862 | break; | |
863 | default: | |
864 | Kind = SectionKind::getMergeableConst(); | |
865 | break; | |
866 | } | |
867 | } | |
868 | return Kind; | |
869 | } | |
870 | ||
223e47cc LB |
871 | MachineConstantPool::~MachineConstantPool() { |
872 | for (unsigned i = 0, e = Constants.size(); i != e; ++i) | |
873 | if (Constants[i].isMachineConstantPoolEntry()) | |
874 | delete Constants[i].Val.MachineCPVal; | |
875 | for (DenseSet<MachineConstantPoolValue*>::iterator I = | |
876 | MachineCPVsSharingEntries.begin(), E = MachineCPVsSharingEntries.end(); | |
877 | I != E; ++I) | |
878 | delete *I; | |
879 | } | |
880 | ||
881 | /// CanShareConstantPoolEntry - Test whether the given two constants | |
882 | /// can be allocated the same constant pool entry. | |
883 | static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B, | |
970d7e83 | 884 | const DataLayout *TD) { |
223e47cc LB |
885 | // Handle the trivial case quickly. |
886 | if (A == B) return true; | |
887 | ||
888 | // If they have the same type but weren't the same constant, quickly | |
889 | // reject them. | |
890 | if (A->getType() == B->getType()) return false; | |
891 | ||
892 | // We can't handle structs or arrays. | |
893 | if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) || | |
894 | isa<StructType>(B->getType()) || isa<ArrayType>(B->getType())) | |
895 | return false; | |
1a4d82fc | 896 | |
223e47cc LB |
897 | // For now, only support constants with the same size. |
898 | uint64_t StoreSize = TD->getTypeStoreSize(A->getType()); | |
1a4d82fc | 899 | if (StoreSize != TD->getTypeStoreSize(B->getType()) || StoreSize > 128) |
223e47cc LB |
900 | return false; |
901 | ||
902 | Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8); | |
903 | ||
904 | // Try constant folding a bitcast of both instructions to an integer. If we | |
905 | // get two identical ConstantInt's, then we are good to share them. We use | |
906 | // the constant folding APIs to do this so that we get the benefit of | |
970d7e83 | 907 | // DataLayout. |
223e47cc LB |
908 | if (isa<PointerType>(A->getType())) |
909 | A = ConstantFoldInstOperands(Instruction::PtrToInt, IntTy, | |
910 | const_cast<Constant*>(A), TD); | |
911 | else if (A->getType() != IntTy) | |
912 | A = ConstantFoldInstOperands(Instruction::BitCast, IntTy, | |
913 | const_cast<Constant*>(A), TD); | |
914 | if (isa<PointerType>(B->getType())) | |
915 | B = ConstantFoldInstOperands(Instruction::PtrToInt, IntTy, | |
916 | const_cast<Constant*>(B), TD); | |
917 | else if (B->getType() != IntTy) | |
918 | B = ConstantFoldInstOperands(Instruction::BitCast, IntTy, | |
919 | const_cast<Constant*>(B), TD); | |
920 | ||
921 | return A == B; | |
922 | } | |
923 | ||
924 | /// getConstantPoolIndex - Create a new entry in the constant pool or return | |
925 | /// an existing one. User must specify the log2 of the minimum required | |
926 | /// alignment for the object. | |
927 | /// | |
1a4d82fc | 928 | unsigned MachineConstantPool::getConstantPoolIndex(const Constant *C, |
223e47cc LB |
929 | unsigned Alignment) { |
930 | assert(Alignment && "Alignment must be specified!"); | |
931 | if (Alignment > PoolAlignment) PoolAlignment = Alignment; | |
932 | ||
933 | // Check to see if we already have this constant. | |
934 | // | |
935 | // FIXME, this could be made much more efficient for large constant pools. | |
936 | for (unsigned i = 0, e = Constants.size(); i != e; ++i) | |
937 | if (!Constants[i].isMachineConstantPoolEntry() && | |
1a4d82fc JJ |
938 | CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, |
939 | getDataLayout())) { | |
223e47cc LB |
940 | if ((unsigned)Constants[i].getAlignment() < Alignment) |
941 | Constants[i].Alignment = Alignment; | |
942 | return i; | |
943 | } | |
944 | ||
945 | Constants.push_back(MachineConstantPoolEntry(C, Alignment)); | |
946 | return Constants.size()-1; | |
947 | } | |
948 | ||
949 | unsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V, | |
950 | unsigned Alignment) { | |
951 | assert(Alignment && "Alignment must be specified!"); | |
952 | if (Alignment > PoolAlignment) PoolAlignment = Alignment; | |
953 | ||
954 | // Check to see if we already have this constant. | |
955 | // | |
956 | // FIXME, this could be made much more efficient for large constant pools. | |
957 | int Idx = V->getExistingMachineCPValue(this, Alignment); | |
958 | if (Idx != -1) { | |
959 | MachineCPVsSharingEntries.insert(V); | |
960 | return (unsigned)Idx; | |
961 | } | |
962 | ||
963 | Constants.push_back(MachineConstantPoolEntry(V, Alignment)); | |
964 | return Constants.size()-1; | |
965 | } | |
966 | ||
967 | void MachineConstantPool::print(raw_ostream &OS) const { | |
968 | if (Constants.empty()) return; | |
969 | ||
970 | OS << "Constant Pool:\n"; | |
971 | for (unsigned i = 0, e = Constants.size(); i != e; ++i) { | |
972 | OS << " cp#" << i << ": "; | |
973 | if (Constants[i].isMachineConstantPoolEntry()) | |
974 | Constants[i].Val.MachineCPVal->print(OS); | |
975 | else | |
1a4d82fc | 976 | Constants[i].Val.ConstVal->printAsOperand(OS, /*PrintType=*/false); |
223e47cc LB |
977 | OS << ", align=" << Constants[i].getAlignment(); |
978 | OS << "\n"; | |
979 | } | |
980 | } | |
981 | ||
982 | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) | |
983 | void MachineConstantPool::dump() const { print(dbgs()); } | |
984 | #endif |