← Back to branch summary

~ubuntu-branches/ubuntu/wily/clamav/wily-proposed

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/CodeGen/MachineFunction.cpp

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman, Sebastian Andrzej Siewior, Andreas Cadhalpun, Scott Kitterman, Javier Fernández-Sanguino
  • Date: 2015-01-28 00:25:13 UTC
  • mfrom: (0.48.14 sid)
  • Revision ID: package-import@ubuntu.com-20150128002513-lil2oi74cooy4lzr
Tags: 0.98.6+dfsg-1
http://bugs.debian.org/774686
http://bugs.debian.org/767350
http://bugs.debian.org/775400
http://bugs.debian.org/767353
http://bugs.debian.org/773563
[ Sebastian Andrzej Siewior ]
* update "fix-ssize_t-size_t-off_t-printf-modifier", include of misc.h was
  missing but was pulled in via the systemd patch.
* Don't leak return codes from libmspack to clamav API. (Closes: #774686).

[ Andreas Cadhalpun ]
* Add patch to avoid emitting incremental progress messages when not
  outputting to a terminal. (Closes: #767350)
* Update lintian-overrides for unused-file-paragraph-in-dep5-copyright.
* clamav-base.postinst: always chown /var/log/clamav and /var/lib/clamav
  to clamav:clamav, not only on fresh installations. (Closes: #775400)
* Adapt the clamav-daemon and clamav-freshclam logrotate scripts,
  so that they correctly work under systemd.
* Move the PidFile variable from the clamd/freshclam configuration files
  to the init scripts. This makes the init scripts more robust against
  misconfiguration and avoids error messages with systemd. (Closes: #767353)
* debian/copyright: drop files from Files-Excluded only present in github
  tarballs
* Drop Workaround-a-bug-in-libc-on-Hurd.patch, because hurd got fixed.
  (see #752237)
* debian/rules: Remove useless --with-system-tommath --without-included-ltdl
  configure options.

[ Scott Kitterman ]
* Stop stripping llvm when repacking the tarball as the system llvm on some
  releases is too old to use
* New upstream bugfix release
  - Library shared object revisions.
  - Includes a patch from Sebastian Andrzej Siewior making ClamAV pid files
    compatible with systemd.
  - Fix a heap out of bounds condition with crafted Yoda's crypter files.
    This issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted mew packer files. This
    issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted upx packer files. This
    issue was discovered by Kevin Szkudlapski of Quarkslab.
  - Fix a heap out of bounds condition with crafted upack packer files. This
    issue was discovered by Sebastian Andrzej Siewior. CVE-2014-9328.
  - Compensate a crash due to incorrect compiler optimization when handling
    crafted petite packer files. This issue was discovered by Sebastian
    Andrzej Siewior.
* Update lintian override for embedded zlib to match new so version

[ Javier Fernández-Sanguino ]
* Updated Spanish Debconf template translation (Closes: #773563)

Show diffs side-by-side

added added

removed removed

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