LLVM  6.0.0svn
PseudoSourceValue.cpp
Go to the documentation of this file.
1 //===-- llvm/CodeGen/PseudoSourceValue.cpp ----------------------*- C++ -*-===//
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 // This file implements the PseudoSourceValue class.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/IR/DerivedTypes.h"
19 #include "llvm/IR/LLVMContext.h"
22 using namespace llvm;
23 
24 static const char *const PSVNames[] = {
25  "Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack",
26  "GlobalValueCallEntry", "ExternalSymbolCallEntry"};
27 
29  : Kind(Kind) {
31 }
32 
33 
35 
36 void PseudoSourceValue::printCustom(raw_ostream &O) const {
37  if (Kind < TargetCustom)
38  O << PSVNames[Kind];
39  else
40  O << "TargetCustom" << Kind;
41 }
42 
44  if (isStack())
45  return false;
46  if (isGOT() || isConstantPool() || isJumpTable())
47  return true;
48  llvm_unreachable("Unknown PseudoSourceValue!");
49 }
50 
52  if (isStack() || isGOT() || isConstantPool() || isJumpTable())
53  return false;
54  llvm_unreachable("Unknown PseudoSourceValue!");
55 }
56 
58  return !(isGOT() || isConstantPool() || isJumpTable());
59 }
60 
62  const MachineFrameInfo *MFI) const {
63  return MFI && MFI->isImmutableObjectIndex(FI);
64 }
65 
67  if (!MFI)
68  return true;
69  return MFI->isAliasedObjectIndex(FI);
70 }
71 
73  if (!MFI)
74  return true;
75  // Spill slots will not alias any LLVM IR value.
76  return !MFI->isSpillSlotObjectIndex(FI);
77 }
78 
80  OS << "FixedStack" << FI;
81 }
82 
84  PSVKind Kind, const TargetInstrInfo &TII)
85  : PseudoSourceValue(Kind, TII) {}
86 
88  return false;
89 }
90 
92  return false;
93 }
94 
96  return false;
97 }
98 
100  const GlobalValue *GV,
101  const TargetInstrInfo &TII)
104  const char *ES, const TargetInstrInfo &TII)
106 
108  const TargetInstrInfo &TIInfo)
109  : TII(TIInfo),
110  StackPSV(PseudoSourceValue::Stack, TII),
111  GOTPSV(PseudoSourceValue::GOT, TII),
112  JumpTablePSV(PseudoSourceValue::JumpTable, TII),
113  ConstantPoolPSV(PseudoSourceValue::ConstantPool, TII) {}
114 
116  return &StackPSV;
117 }
118 
120 
122  return &ConstantPoolPSV;
123 }
124 
126  return &JumpTablePSV;
127 }
128 
129 const PseudoSourceValue *
131  std::unique_ptr<FixedStackPseudoSourceValue> &V = FSValues[FI];
132  if (!V)
133  V = llvm::make_unique<FixedStackPseudoSourceValue>(FI, TII);
134  return V.get();
135 }
136 
137 const PseudoSourceValue *
139  std::unique_ptr<const GlobalValuePseudoSourceValue> &E =
140  GlobalCallEntries[GV];
141  if (!E)
142  E = llvm::make_unique<GlobalValuePseudoSourceValue>(GV, TII);
143  return E.get();
144 }
145 
146 const PseudoSourceValue *
148  std::unique_ptr<const ExternalSymbolPseudoSourceValue> &E =
149  ExternalCallEntries[ES];
150  if (!E)
151  E = llvm::make_unique<ExternalSymbolPseudoSourceValue>(ES, TII);
152  return E.get();
153 }
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
CallEntryPseudoSourceValue(PSVKind Kind, const TargetInstrInfo &TII)
virtual bool mayAlias(const MachineFrameInfo *) const
Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR Value...
virtual bool isAliased(const MachineFrameInfo *) const
Test whether the memory pointed to by this PseudoSourceValue may also be pointed to by an LLVM IR Val...
virtual bool isConstant(const MachineFrameInfo *) const
Test whether the memory pointed to by this PseudoSourceValue has a constant value.
const HexagonInstrInfo * TII
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
bool isImmutableObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to an immutable object.
bool isAliased(const MachineFrameInfo *) const override
Test whether the memory pointed to by this PseudoSourceValue may also be pointed to by an LLVM IR Val...
bool isConstant(const MachineFrameInfo *MFI) const override
Test whether the memory pointed to by this PseudoSourceValue has a constant value.
bool mayAlias(const MachineFrameInfo *) const override
Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR Value...
const PseudoSourceValue * getFixedStack(int FI)
Return a pseudo source value referencing a fixed stack frame entry, e.g., a spill slot...
TargetInstrInfo - Interface to description of machine instruction set.
ExternalSymbolPseudoSourceValue(const char *ES, const TargetInstrInfo &TII)
const PseudoSourceValue * getExternalSymbolCallEntry(const char *ES)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
virtual unsigned getAddressSpaceForPseudoSourceKind(PseudoSourceValue::PSVKind Kind) const
getAddressSpaceForPseudoSourceKind - Given the kind of memory (e.g.
AddressSpace
Definition: NVPTXBaseInfo.h:22
GlobalValuePseudoSourceValue(const GlobalValue *GV, const TargetInstrInfo &TII)
Special value supplied for machine level alias analysis.
const PseudoSourceValue * getJumpTable()
Return a pseudo source value referencing a jump table.
const PseudoSourceValue * getGlobalValueCallEntry(const GlobalValue *GV)
const PseudoSourceValue * getGOT()
Return a pseudo source value referencing the global offset table (or something the like)...
PseudoSourceValue(PSVKind Kind, const TargetInstrInfo &TII)
bool isAliasedObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to an object that might be pointed to by an LLVM IR v...
static const char *const PSVNames[]
bool isAliased(const MachineFrameInfo *MFI) const override
Test whether the memory pointed to by this PseudoSourceValue may also be pointed to by an LLVM IR Val...
const unsigned Kind
const PseudoSourceValue * getStack()
Return a pseudo source value referencing the area below the stack frame of a function, e.g., the argument space.
bool isConstant(const MachineFrameInfo *) const override
Test whether the memory pointed to by this PseudoSourceValue has a constant value.
PseudoSourceValueManager(const TargetInstrInfo &TII)
void printCustom(raw_ostream &OS) const override
Implement printing for PseudoSourceValue.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
bool mayAlias(const MachineFrameInfo *) const override
Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR Value...
const PseudoSourceValue * getConstantPool()
Return a pseudo source value referencing the constant pool.
bool isSpillSlotObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a spill slot.