/usr/include/llvm-3.9/llvm/CodeGen/PseudoSourceValue.h is in llvm-3.9-dev 1:3.9.1-19ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 | //===-- llvm/CodeGen/PseudoSourceValue.h ------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the PseudoSourceValue class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_PSEUDOSOURCEVALUE_H
#define LLVM_CODEGEN_PSEUDOSOURCEVALUE_H
#include "llvm/ADT/StringMap.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/Value.h"
#include "llvm/IR/ValueMap.h"
#include <map>
namespace llvm {
class MachineFrameInfo;
class MachineMemOperand;
class raw_ostream;
raw_ostream &operator<<(raw_ostream &OS, const MachineMemOperand &MMO);
class PseudoSourceValue;
raw_ostream &operator<<(raw_ostream &OS, const PseudoSourceValue* PSV);
/// Special value supplied for machine level alias analysis. It indicates that
/// a memory access references the functions stack frame (e.g., a spill slot),
/// below the stack frame (e.g., argument space), or constant pool.
class PseudoSourceValue {
public:
enum PSVKind {
Stack,
GOT,
JumpTable,
ConstantPool,
FixedStack,
GlobalValueCallEntry,
ExternalSymbolCallEntry
};
private:
PSVKind Kind;
friend raw_ostream &llvm::operator<<(raw_ostream &OS,
const PseudoSourceValue* PSV);
friend class MachineMemOperand; // For printCustom().
/// Implement printing for PseudoSourceValue. This is called from
/// Value::print or Value's operator<<.
virtual void printCustom(raw_ostream &O) const;
public:
explicit PseudoSourceValue(PSVKind Kind);
virtual ~PseudoSourceValue();
PSVKind kind() const { return Kind; }
bool isStack() const { return Kind == Stack; }
bool isGOT() const { return Kind == GOT; }
bool isConstantPool() const { return Kind == ConstantPool; }
bool isJumpTable() const { return Kind == JumpTable; }
/// Test whether the memory pointed to by this PseudoSourceValue has a
/// constant value.
virtual bool isConstant(const MachineFrameInfo *) const;
/// Test whether the memory pointed to by this PseudoSourceValue may also be
/// pointed to by an LLVM IR Value.
virtual bool isAliased(const MachineFrameInfo *) const;
/// Return true if the memory pointed to by this PseudoSourceValue can ever
/// alias an LLVM IR Value.
virtual bool mayAlias(const MachineFrameInfo *) const;
};
/// A specialized PseudoSourceValue for holding FixedStack values, which must
/// include a frame index.
class FixedStackPseudoSourceValue : public PseudoSourceValue {
const int FI;
public:
explicit FixedStackPseudoSourceValue(int FI)
: PseudoSourceValue(FixedStack), FI(FI) {}
static inline bool classof(const PseudoSourceValue *V) {
return V->kind() == FixedStack;
}
bool isConstant(const MachineFrameInfo *MFI) const override;
bool isAliased(const MachineFrameInfo *MFI) const override;
bool mayAlias(const MachineFrameInfo *) const override;
void printCustom(raw_ostream &OS) const override;
int getFrameIndex() const { return FI; }
};
class CallEntryPseudoSourceValue : public PseudoSourceValue {
protected:
CallEntryPseudoSourceValue(PSVKind Kind);
public:
bool isConstant(const MachineFrameInfo *) const override;
bool isAliased(const MachineFrameInfo *) const override;
bool mayAlias(const MachineFrameInfo *) const override;
};
/// A specialized pseudo soruce value for holding GlobalValue values.
class GlobalValuePseudoSourceValue : public CallEntryPseudoSourceValue {
const GlobalValue *GV;
public:
GlobalValuePseudoSourceValue(const GlobalValue *GV);
static inline bool classof(const PseudoSourceValue *V) {
return V->kind() == GlobalValueCallEntry;
}
const GlobalValue *getValue() const { return GV; }
};
/// A specialized pseudo source value for holding external symbol values.
class ExternalSymbolPseudoSourceValue : public CallEntryPseudoSourceValue {
const char *ES;
public:
ExternalSymbolPseudoSourceValue(const char *ES);
static inline bool classof(const PseudoSourceValue *V) {
return V->kind() == ExternalSymbolCallEntry;
}
const char *getSymbol() const { return ES; }
};
/// Manages creation of pseudo source values.
class PseudoSourceValueManager {
const PseudoSourceValue StackPSV, GOTPSV, JumpTablePSV, ConstantPoolPSV;
std::map<int, std::unique_ptr<FixedStackPseudoSourceValue>> FSValues;
StringMap<std::unique_ptr<const ExternalSymbolPseudoSourceValue>>
ExternalCallEntries;
ValueMap<const GlobalValue *,
std::unique_ptr<const GlobalValuePseudoSourceValue>>
GlobalCallEntries;
public:
PseudoSourceValueManager();
/// Return a pseudo source value referencing the area below the stack frame of
/// a function, e.g., the argument space.
const PseudoSourceValue *getStack();
/// Return a pseudo source value referencing the global offset table
/// (or something the like).
const PseudoSourceValue *getGOT();
/// Return a pseudo source value referencing the constant pool. Since constant
/// pools are constant, this doesn't need to identify a specific constant
/// pool entry.
const PseudoSourceValue *getConstantPool();
/// Return a pseudo source value referencing a jump table. Since jump tables
/// are constant, this doesn't need to identify a specific jump table.
const PseudoSourceValue *getJumpTable();
/// Return a pseudo source value referencing a fixed stack frame entry,
/// e.g., a spill slot.
const PseudoSourceValue *getFixedStack(int FI);
const PseudoSourceValue *getGlobalValueCallEntry(const GlobalValue *GV);
const PseudoSourceValue *getExternalSymbolCallEntry(const char *ES);
};
} // end namespace llvm
#endif
|