MachineFunction.cpp revision c99fd879c0f4bbc56c29d508fec7935e6cbd7ed0 
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/DerivedTypes.h"
17#include "llvm/Function.h"
18#include "llvm/Instructions.h"
19#include "llvm/ADT/STLExtras.h"
20#include "llvm/Config/config.h"
21#include "llvm/CodeGen/MachineConstantPool.h"
22#include "llvm/CodeGen/MachineFunction.h"
23#include "llvm/CodeGen/MachineFunctionPass.h"
24#include "llvm/CodeGen/MachineFrameInfo.h"
25#include "llvm/CodeGen/MachineInstr.h"
26#include "llvm/CodeGen/MachineJumpTableInfo.h"
27#include "llvm/CodeGen/MachineRegisterInfo.h"
28#include "llvm/CodeGen/Passes.h"
29#include "llvm/Analysis/DebugInfo.h"
30#include "llvm/Support/Debug.h"
31#include "llvm/Target/TargetData.h"
32#include "llvm/Target/TargetLowering.h"
33#include "llvm/Target/TargetMachine.h"
34#include "llvm/Target/TargetFrameInfo.h"
35#include "llvm/Support/GraphWriter.h"
36#include "llvm/Support/raw_ostream.h"
37using namespace llvm;
38
39namespace {
40  struct Printer : public MachineFunctionPass {
41    static char ID;
42
43    raw_ostream &OS;
44    const std::string Banner;
45
46    Printer(raw_ostream &os, const std::string &banner)
47      : MachineFunctionPass(&ID), OS(os), Banner(banner) {}
48
49    const char *getPassName() const { return "MachineFunction Printer"; }
50
51    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
52      AU.setPreservesAll();
53      MachineFunctionPass::getAnalysisUsage(AU);
54    }
55
56    bool runOnMachineFunction(MachineFunction &MF) {
57      OS << "# " << Banner << ":\n";
58      MF.print(OS);
59      return false;
60    }
61  };
62  char Printer::ID = 0;
63}
64
65/// Returns a newly-created MachineFunction Printer pass. The default banner is
66/// empty.
67///
68FunctionPass *llvm::createMachineFunctionPrinterPass(raw_ostream &OS,
69                                                     const std::string &Banner){
70  return new Printer(OS, Banner);
71}
72
73//===---------------------------------------------------------------------===//
74// MachineFunction implementation
75//===---------------------------------------------------------------------===//
76
77// Out of line virtual method.
78MachineFunctionInfo::~MachineFunctionInfo() {}
79
80void ilist_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) {
81  MBB->getParent()->DeleteMachineBasicBlock(MBB);
82}
83
84MachineFunction::MachineFunction(Function *F,
85                                 const TargetMachine &TM)
86  : Fn(F), Target(TM) {
87  if (TM.getRegisterInfo())
88    RegInfo = new (Allocator.Allocate<MachineRegisterInfo>())
89                  MachineRegisterInfo(*TM.getRegisterInfo());
90  else
91    RegInfo = 0;
92  MFInfo = 0;
93  FrameInfo = new (Allocator.Allocate<MachineFrameInfo>())
94                  MachineFrameInfo(*TM.getFrameInfo());
95  ConstantPool = new (Allocator.Allocate<MachineConstantPool>())
96                     MachineConstantPool(TM.getTargetData());
97  Alignment = TM.getTargetLowering()->getFunctionAlignment(F);
98
99  // Set up jump table.
100  const TargetData &TD = *TM.getTargetData();
101  bool IsPic = TM.getRelocationModel() == Reloc::PIC_;
102  unsigned EntrySize = IsPic ? 4 : TD.getPointerSize();
103  unsigned TyAlignment = IsPic ?
104                       TD.getABITypeAlignment(Type::getInt32Ty(F->getContext()))
105                               : TD.getPointerABIAlignment();
106  JumpTableInfo = new (Allocator.Allocate<MachineJumpTableInfo>())
107                      MachineJumpTableInfo(EntrySize, TyAlignment);
108}
109
110MachineFunction::~MachineFunction() {
111  BasicBlocks.clear();
112  InstructionRecycler.clear(Allocator);
113  BasicBlockRecycler.clear(Allocator);
114  if (RegInfo) {
115    RegInfo->~MachineRegisterInfo();
116    Allocator.Deallocate(RegInfo);
117  }
118  if (MFInfo) {
119    MFInfo->~MachineFunctionInfo();
120    Allocator.Deallocate(MFInfo);
121  }
122  FrameInfo->~MachineFrameInfo();         Allocator.Deallocate(FrameInfo);
123  ConstantPool->~MachineConstantPool();   Allocator.Deallocate(ConstantPool);
124  JumpTableInfo->~MachineJumpTableInfo(); Allocator.Deallocate(JumpTableInfo);
125}
126
127
128/// RenumberBlocks - This discards all of the MachineBasicBlock numbers and
129/// recomputes them.  This guarantees that the MBB numbers are sequential,
130/// dense, and match the ordering of the blocks within the function.  If a
131/// specific MachineBasicBlock is specified, only that block and those after
132/// it are renumbered.
133void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) {
134  if (empty()) { MBBNumbering.clear(); return; }
135  MachineFunction::iterator MBBI, E = end();
136  if (MBB == 0)
137    MBBI = begin();
138  else
139    MBBI = MBB;
140
141  // Figure out the block number this should have.
142  unsigned BlockNo = 0;
143  if (MBBI != begin())
144    BlockNo = prior(MBBI)->getNumber()+1;
145
146  for (; MBBI != E; ++MBBI, ++BlockNo) {
147    if (MBBI->getNumber() != (int)BlockNo) {
148      // Remove use of the old number.
149      if (MBBI->getNumber() != -1) {
150        assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&
151               "MBB number mismatch!");
152        MBBNumbering[MBBI->getNumber()] = 0;
153      }
154
155      // If BlockNo is already taken, set that block's number to -1.
156      if (MBBNumbering[BlockNo])
157        MBBNumbering[BlockNo]->setNumber(-1);
158
159      MBBNumbering[BlockNo] = MBBI;
160      MBBI->setNumber(BlockNo);
161    }
162  }
163
164  // Okay, all the blocks are renumbered.  If we have compactified the block
165  // numbering, shrink MBBNumbering now.
166  assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
167  MBBNumbering.resize(BlockNo);
168}
169
170/// CreateMachineInstr - Allocate a new MachineInstr. Use this instead
171/// of `new MachineInstr'.
172///
173MachineInstr *
174MachineFunction::CreateMachineInstr(const TargetInstrDesc &TID,
175                                    DebugLoc DL, bool NoImp) {
176  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
177    MachineInstr(TID, DL, NoImp);
178}
179
180/// CloneMachineInstr - Create a new MachineInstr which is a copy of the
181/// 'Orig' instruction, identical in all ways except the the instruction
182/// has no parent, prev, or next.
183///
184MachineInstr *
185MachineFunction::CloneMachineInstr(const MachineInstr *Orig) {
186  return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
187             MachineInstr(*this, *Orig);
188}
189
190/// DeleteMachineInstr - Delete the given MachineInstr.
191///
192void
193MachineFunction::DeleteMachineInstr(MachineInstr *MI) {
194  MI->~MachineInstr();
195  InstructionRecycler.Deallocate(Allocator, MI);
196}
197
198/// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this
199/// instead of `new MachineBasicBlock'.
200///
201MachineBasicBlock *
202MachineFunction::CreateMachineBasicBlock(const BasicBlock *bb) {
203  return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator))
204             MachineBasicBlock(*this, bb);
205}
206
207/// DeleteMachineBasicBlock - Delete the given MachineBasicBlock.
208///
209void
210MachineFunction::DeleteMachineBasicBlock(MachineBasicBlock *MBB) {
211  assert(MBB->getParent() == this && "MBB parent mismatch!");
212  MBB->~MachineBasicBlock();
213  BasicBlockRecycler.Deallocate(Allocator, MBB);
214}
215
216MachineMemOperand *
217MachineFunction::getMachineMemOperand(const Value *v, unsigned f,
218                                      int64_t o, uint64_t s,
219                                      unsigned base_alignment) {
220  return new (Allocator.Allocate<MachineMemOperand>())
221             MachineMemOperand(v, f, o, s, base_alignment);
222}
223
224MachineMemOperand *
225MachineFunction::getMachineMemOperand(const MachineMemOperand *MMO,
226                                      int64_t Offset, uint64_t Size) {
227  return new (Allocator.Allocate<MachineMemOperand>())
228             MachineMemOperand(MMO->getValue(), MMO->getFlags(),
229                               int64_t(uint64_t(MMO->getOffset()) +
230                                       uint64_t(Offset)),
231                               Size, MMO->getBaseAlignment());
232}
233
234MachineInstr::mmo_iterator
235MachineFunction::allocateMemRefsArray(unsigned long Num) {
236  return Allocator.Allocate<MachineMemOperand *>(Num);
237}
238
239std::pair<MachineInstr::mmo_iterator, MachineInstr::mmo_iterator>
240MachineFunction::extractLoadMemRefs(MachineInstr::mmo_iterator Begin,
241                                    MachineInstr::mmo_iterator End) {
242  // Count the number of load mem refs.
243  unsigned Num = 0;
244  for (MachineInstr::mmo_iterator I = Begin; I != End; ++I)
245    if ((*I)->isLoad())
246      ++Num;
247
248  // Allocate a new array and populate it with the load information.
249  MachineInstr::mmo_iterator Result = allocateMemRefsArray(Num);
250  unsigned Index = 0;
251  for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) {
252    if ((*I)->isLoad()) {
253      if (!(*I)->isStore())
254        // Reuse the MMO.
255        Result[Index] = *I;
256      else {
257        // Clone the MMO and unset the store flag.
258        MachineMemOperand *JustLoad =
259          getMachineMemOperand((*I)->getValue(),
260                               (*I)->getFlags() & ~MachineMemOperand::MOStore,
261                               (*I)->getOffset(), (*I)->getSize(),
262                               (*I)->getBaseAlignment());
263        Result[Index] = JustLoad;
264      }
265      ++Index;
266    }
267  }
268  return std::make_pair(Result, Result + Num);
269}
270
271std::pair<MachineInstr::mmo_iterator, MachineInstr::mmo_iterator>
272MachineFunction::extractStoreMemRefs(MachineInstr::mmo_iterator Begin,
273                                     MachineInstr::mmo_iterator End) {
274  // Count the number of load mem refs.
275  unsigned Num = 0;
276  for (MachineInstr::mmo_iterator I = Begin; I != End; ++I)
277    if ((*I)->isStore())
278      ++Num;
279
280  // Allocate a new array and populate it with the store information.
281  MachineInstr::mmo_iterator Result = allocateMemRefsArray(Num);
282  unsigned Index = 0;
283  for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) {
284    if ((*I)->isStore()) {
285      if (!(*I)->isLoad())
286        // Reuse the MMO.
287        Result[Index] = *I;
288      else {
289        // Clone the MMO and unset the load flag.
290        MachineMemOperand *JustStore =
291          getMachineMemOperand((*I)->getValue(),
292                               (*I)->getFlags() & ~MachineMemOperand::MOLoad,
293                               (*I)->getOffset(), (*I)->getSize(),
294                               (*I)->getBaseAlignment());
295        Result[Index] = JustStore;
296      }
297      ++Index;
298    }
299  }
300  return std::make_pair(Result, Result + Num);
301}
302
303void MachineFunction::dump() const {
304  print(dbgs());
305}
306
307void MachineFunction::print(raw_ostream &OS) const {
308  OS << "# Machine code for function " << Fn->getName() << ":\n";
309
310  // Print Frame Information
311  FrameInfo->print(*this, OS);
312
313  // Print JumpTable Information
314  JumpTableInfo->print(OS);
315
316  // Print Constant Pool
317  ConstantPool->print(OS);
318
319  const TargetRegisterInfo *TRI = getTarget().getRegisterInfo();
320
321  if (RegInfo && !RegInfo->livein_empty()) {
322    OS << "Function Live Ins: ";
323    for (MachineRegisterInfo::livein_iterator
324         I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
325      if (TRI)
326        OS << "%" << TRI->getName(I->first);
327      else
328        OS << " %physreg" << I->first;
329
330      if (I->second)
331        OS << " in reg%" << I->second;
332
333      if (llvm::next(I) != E)
334        OS << ", ";
335    }
336    OS << '\n';
337  }
338  if (RegInfo && !RegInfo->liveout_empty()) {
339    OS << "Function Live Outs: ";
340    for (MachineRegisterInfo::liveout_iterator
341         I = RegInfo->liveout_begin(), E = RegInfo->liveout_end(); I != E; ++I){
342      if (TRI)
343        OS << '%' << TRI->getName(*I);
344      else
345        OS << "%physreg" << *I;
346
347      if (llvm::next(I) != E)
348        OS << " ";
349    }
350    OS << '\n';
351  }
352
353  for (const_iterator BB = begin(), E = end(); BB != E; ++BB) {
354    OS << '\n';
355    BB->print(OS);
356  }
357
358  OS << "\n# End machine code for function " << Fn->getName() << ".\n\n";
359}
360
361namespace llvm {
362  template<>
363  struct DOTGraphTraits<const MachineFunction*> : public DefaultDOTGraphTraits {
364
365  DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {}
366
367    static std::string getGraphName(const MachineFunction *F) {
368      return "CFG for '" + F->getFunction()->getNameStr() + "' function";
369    }
370
371    std::string getNodeLabel(const MachineBasicBlock *Node,
372                             const MachineFunction *Graph) {
373      if (isSimple () && Node->getBasicBlock() &&
374          !Node->getBasicBlock()->getName().empty())
375        return Node->getBasicBlock()->getNameStr() + ":";
376
377      std::string OutStr;
378      {
379        raw_string_ostream OSS(OutStr);
380
381        if (isSimple())
382          OSS << Node->getNumber() << ':';
383        else
384          Node->print(OSS);
385      }
386
387      if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
388
389      // Process string output to make it nicer...
390      for (unsigned i = 0; i != OutStr.length(); ++i)
391        if (OutStr[i] == '\n') {                            // Left justify
392          OutStr[i] = '\\';
393          OutStr.insert(OutStr.begin()+i+1, 'l');
394        }
395      return OutStr;
396    }
397  };
398}
399
400void MachineFunction::viewCFG() const
401{
402#ifndef NDEBUG
403  ViewGraph(this, "mf" + getFunction()->getNameStr());
404#else
405  errs() << "SelectionDAG::viewGraph is only available in debug builds on "
406         << "systems with Graphviz or gv!\n";
407#endif // NDEBUG
408}
409
410void MachineFunction::viewCFGOnly() const
411{
412#ifndef NDEBUG
413  ViewGraph(this, "mf" + getFunction()->getNameStr(), true);
414#else
415  errs() << "SelectionDAG::viewGraph is only available in debug builds on "
416         << "systems with Graphviz or gv!\n";
417#endif // NDEBUG
418}
419
420/// addLiveIn - Add the specified physical register as a live-in value and
421/// create a corresponding virtual register for it.
422unsigned MachineFunction::addLiveIn(unsigned PReg,
423                                    const TargetRegisterClass *RC) {
424  assert(RC->contains(PReg) && "Not the correct regclass!");
425  unsigned VReg = getRegInfo().createVirtualRegister(RC);
426  getRegInfo().addLiveIn(PReg, VReg);
427  return VReg;
428}
429
430/// getDILocation - Get the DILocation for a given DebugLoc object.
431DILocation MachineFunction::getDILocation(DebugLoc DL) const {
432  unsigned Idx = DL.getIndex();
433  assert(Idx < DebugLocInfo.DebugLocations.size() &&
434         "Invalid index into debug locations!");
435  return DILocation(DebugLocInfo.DebugLocations[Idx]);
436}
437
438//===----------------------------------------------------------------------===//
439//  MachineFrameInfo implementation
440//===----------------------------------------------------------------------===//
441
442/// CreateFixedObject - Create a new object at a fixed location on the stack.
443/// All fixed objects should be created before other objects are created for
444/// efficiency. By default, fixed objects are immutable. This returns an
445/// index with a negative value.
446///
447int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset,
448                                        bool Immutable, bool isSS) {
449  assert(Size != 0 && "Cannot allocate zero size fixed stack objects!");
450  Objects.insert(Objects.begin(), StackObject(Size, 1, SPOffset, Immutable,
451                                              isSS));
452  return -++NumFixedObjects;
453}
454
455
456BitVector
457MachineFrameInfo::getPristineRegs(const MachineBasicBlock *MBB) const {
458  assert(MBB && "MBB must be valid");
459  const MachineFunction *MF = MBB->getParent();
460  assert(MF && "MBB must be part of a MachineFunction");
461  const TargetMachine &TM = MF->getTarget();
462  const TargetRegisterInfo *TRI = TM.getRegisterInfo();
463  BitVector BV(TRI->getNumRegs());
464
465  // Before CSI is calculated, no registers are considered pristine. They can be
466  // freely used and PEI will make sure they are saved.
467  if (!isCalleeSavedInfoValid())
468    return BV;
469
470  for (const unsigned *CSR = TRI->getCalleeSavedRegs(MF); CSR && *CSR; ++CSR)
471    BV.set(*CSR);
472
473  // The entry MBB always has all CSRs pristine.
474  if (MBB == &MF->front())
475    return BV;
476
477  // On other MBBs the saved CSRs are not pristine.
478  const std::vector<CalleeSavedInfo> &CSI = getCalleeSavedInfo();
479  for (std::vector<CalleeSavedInfo>::const_iterator I = CSI.begin(),
480         E = CSI.end(); I != E; ++I)
481    BV.reset(I->getReg());
482
483  return BV;
484}
485
486
487void MachineFrameInfo::print(const MachineFunction &MF, raw_ostream &OS) const{
488  if (Objects.empty()) return;
489
490  const TargetFrameInfo *FI = MF.getTarget().getFrameInfo();
491  int ValOffset = (FI ? FI->getOffsetOfLocalArea() : 0);
492
493  OS << "Frame Objects:\n";
494
495  for (unsigned i = 0, e = Objects.size(); i != e; ++i) {
496    const StackObject &SO = Objects[i];
497    OS << "  fi#" << (int)(i-NumFixedObjects) << ": ";
498    if (SO.Size == ~0ULL) {
499      OS << "dead\n";
500      continue;
501    }
502    if (SO.Size == 0)
503      OS << "variable sized";
504    else
505      OS << "size=" << SO.Size;
506    OS << ", align=" << SO.Alignment;
507
508    if (i < NumFixedObjects)
509      OS << ", fixed";
510    if (i < NumFixedObjects || SO.SPOffset != -1) {
511      int64_t Off = SO.SPOffset - ValOffset;
512      OS << ", at location [SP";
513      if (Off > 0)
514        OS << "+" << Off;
515      else if (Off < 0)
516        OS << Off;
517      OS << "]";
518    }
519    OS << "\n";
520  }
521}
522
523void MachineFrameInfo::dump(const MachineFunction &MF) const {
524  print(MF, dbgs());
525}
526
527//===----------------------------------------------------------------------===//
528//  MachineJumpTableInfo implementation
529//===----------------------------------------------------------------------===//
530
531/// getJumpTableIndex - Create a new jump table entry in the jump table info
532/// or return an existing one.
533///
534unsigned MachineJumpTableInfo::getJumpTableIndex(
535                               const std::vector<MachineBasicBlock*> &DestBBs) {
536  assert(!DestBBs.empty() && "Cannot create an empty jump table!");
537  JumpTables.push_back(MachineJumpTableEntry(DestBBs));
538  return JumpTables.size()-1;
539}
540
541/// ReplaceMBBInJumpTables - If Old is the target of any jump tables, update
542/// the jump tables to branch to New instead.
543bool
544MachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old,
545                                             MachineBasicBlock *New) {
546  assert(Old != New && "Not making a change?");
547  bool MadeChange = false;
548  for (size_t i = 0, e = JumpTables.size(); i != e; ++i)
549    ReplaceMBBInJumpTable(i, Old, New);
550  return MadeChange;
551}
552
553/// ReplaceMBBInJumpTable - If Old is a target of the jump tables, update
554/// the jump table to branch to New instead.
555bool
556MachineJumpTableInfo::ReplaceMBBInJumpTable(unsigned Idx,
557                                            MachineBasicBlock *Old,
558                                            MachineBasicBlock *New) {
559  assert(Old != New && "Not making a change?");
560  bool MadeChange = false;
561  MachineJumpTableEntry &JTE = JumpTables[Idx];
562  for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j)
563    if (JTE.MBBs[j] == Old) {
564      JTE.MBBs[j] = New;
565      MadeChange = true;
566    }
567  return MadeChange;
568}
569
570void MachineJumpTableInfo::print(raw_ostream &OS) const {
571  if (JumpTables.empty()) return;
572
573  OS << "Jump Tables:\n";
574
575  for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
576    OS << "  jt#" << i << ": ";
577    for (unsigned j = 0, f = JumpTables[i].MBBs.size(); j != f; ++j)
578      OS << " BB#" << JumpTables[i].MBBs[j]->getNumber();
579  }
580
581  OS << '\n';
582}
583
584void MachineJumpTableInfo::dump() const { print(dbgs()); }
585
586
587//===----------------------------------------------------------------------===//
588//  MachineConstantPool implementation
589//===----------------------------------------------------------------------===//
590
591const Type *MachineConstantPoolEntry::getType() const {
592  if (isMachineConstantPoolEntry())
593    return Val.MachineCPVal->getType();
594  return Val.ConstVal->getType();
595}
596
597
598unsigned MachineConstantPoolEntry::getRelocationInfo() const {
599  if (isMachineConstantPoolEntry())
600    return Val.MachineCPVal->getRelocationInfo();
601  return Val.ConstVal->getRelocationInfo();
602}
603
604MachineConstantPool::~MachineConstantPool() {
605  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
606    if (Constants[i].isMachineConstantPoolEntry())
607      delete Constants[i].Val.MachineCPVal;
608}
609
610/// CanShareConstantPoolEntry - Test whether the given two constants
611/// can be allocated the same constant pool entry.
612static bool CanShareConstantPoolEntry(Constant *A, Constant *B,
613                                      const TargetData *TD) {
614  // Handle the trivial case quickly.
615  if (A == B) return true;
616
617  // If they have the same type but weren't the same constant, quickly
618  // reject them.
619  if (A->getType() == B->getType()) return false;
620
621  // For now, only support constants with the same size.
622  if (TD->getTypeStoreSize(A->getType()) != TD->getTypeStoreSize(B->getType()))
623    return false;
624
625  // If a floating-point value and an integer value have the same encoding,
626  // they can share a constant-pool entry.
627  if (ConstantFP *AFP = dyn_cast<ConstantFP>(A))
628    if (ConstantInt *BI = dyn_cast<ConstantInt>(B))
629      return AFP->getValueAPF().bitcastToAPInt() == BI->getValue();
630  if (ConstantFP *BFP = dyn_cast<ConstantFP>(B))
631    if (ConstantInt *AI = dyn_cast<ConstantInt>(A))
632      return BFP->getValueAPF().bitcastToAPInt() == AI->getValue();
633
634  // Two vectors can share an entry if each pair of corresponding
635  // elements could.
636  if (ConstantVector *AV = dyn_cast<ConstantVector>(A))
637    if (ConstantVector *BV = dyn_cast<ConstantVector>(B)) {
638      if (AV->getType()->getNumElements() != BV->getType()->getNumElements())
639        return false;
640      for (unsigned i = 0, e = AV->getType()->getNumElements(); i != e; ++i)
641        if (!CanShareConstantPoolEntry(AV->getOperand(i),
642                                       BV->getOperand(i), TD))
643          return false;
644      return true;
645    }
646
647  // TODO: Handle other cases.
648
649  return false;
650}
651
652/// getConstantPoolIndex - Create a new entry in the constant pool or return
653/// an existing one.  User must specify the log2 of the minimum required
654/// alignment for the object.
655///
656unsigned MachineConstantPool::getConstantPoolIndex(Constant *C,
657                                                   unsigned Alignment) {
658  assert(Alignment && "Alignment must be specified!");
659  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
660
661  // Check to see if we already have this constant.
662  //
663  // FIXME, this could be made much more efficient for large constant pools.
664  for (unsigned i = 0, e = Constants.size(); i != e; ++i)
665    if (!Constants[i].isMachineConstantPoolEntry() &&
666        CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, TD)) {
667      if ((unsigned)Constants[i].getAlignment() < Alignment)
668        Constants[i].Alignment = Alignment;
669      return i;
670    }
671
672  Constants.push_back(MachineConstantPoolEntry(C, Alignment));
673  return Constants.size()-1;
674}
675
676unsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V,
677                                                   unsigned Alignment) {
678  assert(Alignment && "Alignment must be specified!");
679  if (Alignment > PoolAlignment) PoolAlignment = Alignment;
680
681  // Check to see if we already have this constant.
682  //
683  // FIXME, this could be made much more efficient for large constant pools.
684  int Idx = V->getExistingMachineCPValue(this, Alignment);
685  if (Idx != -1)
686    return (unsigned)Idx;
687
688  Constants.push_back(MachineConstantPoolEntry(V, Alignment));
689  return Constants.size()-1;
690}
691
692void MachineConstantPool::print(raw_ostream &OS) const {
693  if (Constants.empty()) return;
694
695  OS << "Constant Pool:\n";
696  for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
697    OS << "  cp#" << i << ": ";
698    if (Constants[i].isMachineConstantPoolEntry())
699      Constants[i].Val.MachineCPVal->print(OS);
700    else
701      OS << *(Value*)Constants[i].Val.ConstVal;
702    OS << ", align=" << Constants[i].getAlignment();
703    OS << "\n";
704  }
705}
706
707void MachineConstantPool::dump() const { print(dbgs()); }
708