RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-02-09 05:47:13 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

PseudoSourceValue: Transform the mips subclass to target independent subclasses

Browse Source 
This commit transforms the mips-specific 'MipsCallEntry' subclass of the
'PseudoSourceValue' class into two, target-independent subclasses named
'GlobalValuePseudoSourceValue' and 'ExternalSymbolPseudoSourceValue'.

This change makes it easier to serialize the pseudo source values by removing
target-specific pseudo source values.

Reviewers: Akira Hatanaka
llvm-svn: 244698
This commit is contained in:
Alex Lorenz 2015-08-11 23:23:17 +00:00
parent 7b1d22a17d
commit ce2812bb8e
4 changed files with 102 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
include/llvm/CodeGen/PseudoSourceValue.h
View File

@ -14,7 +14,10 @@
#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 {
@ -30,7 +33,15 @@ raw_ostream &operator<<(raw_ostream &OS, const MachineMemOperand &MMO);
/// below the stack frame (e.g., argument space), or constant pool.
class PseudoSourceValue {
public:
enum PSVKind { Stack, GOT, JumpTable, ConstantPool, FixedStack, MipsPSV };
enum PSVKind {
Stack,
GOT,
JumpTable,
ConstantPool,
FixedStack,
GlobalValueCallEntry,
ExternalSymbolCallEntry
};
private:
PSVKind Kind;
@ -90,10 +101,45 @@ public:
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);
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);
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();
@ -118,6 +164,10 @@ public:
/// 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

43
lib/CodeGen/PseudoSourceValue.cpp
View File

@ -24,7 +24,8 @@
using namespace llvm;
static const char *const PSVNames[] = {
"Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack", "MipsCallEntry"};
"Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack",
"GlobalValueCallEntry", "ExternalSymbolCallEntry"};
PseudoSourceValue::PseudoSourceValue(PSVKind Kind) : Kind(Kind) {}
@ -76,6 +77,28 @@ void FixedStackPseudoSourceValue::printCustom(raw_ostream &OS) const {
OS << "FixedStack" << FI;
}
CallEntryPseudoSourceValue::CallEntryPseudoSourceValue(PSVKind Kind)
: PseudoSourceValue(Kind) {}
bool CallEntryPseudoSourceValue::isConstant(const MachineFrameInfo *) const {
return false;
}
bool CallEntryPseudoSourceValue::isAliased(const MachineFrameInfo *) const {
return false;
}
bool CallEntryPseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
return false;
}
GlobalValuePseudoSourceValue::GlobalValuePseudoSourceValue(
const GlobalValue *GV)
: CallEntryPseudoSourceValue(GlobalValueCallEntry), GV(GV) {}
ExternalSymbolPseudoSourceValue::ExternalSymbolPseudoSourceValue(const char *ES)
: CallEntryPseudoSourceValue(ExternalSymbolCallEntry), ES(ES) {}
PseudoSourceValueManager::PseudoSourceValueManager()
: StackPSV(PseudoSourceValue::Stack), GOTPSV(PseudoSourceValue::GOT),
JumpTablePSV(PseudoSourceValue::JumpTable),
@ -101,3 +124,21 @@ const PseudoSourceValue *PseudoSourceValueManager::getFixedStack(int FI) {
V = llvm::make_unique<FixedStackPseudoSourceValue>(FI);
return V.get();
}
const PseudoSourceValue *
PseudoSourceValueManager::getGlobalValueCallEntry(const GlobalValue *GV) {
std::unique_ptr<const GlobalValuePseudoSourceValue> &E =
GlobalCallEntries[GV];
if (!E)
E = llvm::make_unique<GlobalValuePseudoSourceValue>(GV);
return E.get();
}
const PseudoSourceValue *
PseudoSourceValueManager::getExternalSymbolCallEntry(const char *ES) {
std::unique_ptr<const ExternalSymbolPseudoSourceValue> &E =
ExternalCallEntries[ES];
if (!E)
E = llvm::make_unique<ExternalSymbolPseudoSourceValue>(ES);
return E.get();
}

55
lib/Target/Mips/MipsMachineFunction.cpp
View File

@ -24,43 +24,6 @@ static cl::opt<bool>
FixGlobalBaseReg("mips-fix-global-base-reg", cl::Hidden, cl::init(true),
cl::desc("Always use $gp as the global base register."));
// class MipsCallEntry.
MipsCallEntry::MipsCallEntry(StringRef N) : PseudoSourceValue(MipsPSV) {
#ifndef NDEBUG
Name = N;
Val = nullptr;
#endif
}
MipsCallEntry::MipsCallEntry(const GlobalValue *V)
: PseudoSourceValue(MipsPSV) {
#ifndef NDEBUG
Val = V;
#endif
}
bool MipsCallEntry::isConstant(const MachineFrameInfo *) const {
return false;
}
bool MipsCallEntry::isAliased(const MachineFrameInfo *) const {
return false;
}
bool MipsCallEntry::mayAlias(const MachineFrameInfo *) const {
return false;
}
void MipsCallEntry::printCustom(raw_ostream &O) const {
O << "MipsCallEntry: ";
#ifndef NDEBUG
if (Val)
O << Val->getName();
else
O << Name;
#endif
}
MipsFunctionInfo::~MipsFunctionInfo() {}
bool MipsFunctionInfo::globalBaseRegSet() const {
@ -117,22 +80,12 @@ bool MipsFunctionInfo::isEhDataRegFI(int FI) const {
|| FI == EhDataRegFI[2] || FI == EhDataRegFI[3]);
}
MachinePointerInfo MipsFunctionInfo::callPtrInfo(StringRef Name) {
std::unique_ptr<const MipsCallEntry> &E = ExternalCallEntries[Name];
if (!E)
E = llvm::make_unique<MipsCallEntry>(Name);
return MachinePointerInfo(E.get());
MachinePointerInfo MipsFunctionInfo::callPtrInfo(const char *ES) {
return MachinePointerInfo(MF.getPSVManager().getExternalSymbolCallEntry(ES));
}
MachinePointerInfo MipsFunctionInfo::callPtrInfo(const GlobalValue *Val) {
std::unique_ptr<const MipsCallEntry> &E = GlobalCallEntries[Val];
if (!E)
E = llvm::make_unique<MipsCallEntry>(Val);
return MachinePointerInfo(E.get());
MachinePointerInfo MipsFunctionInfo::callPtrInfo(const GlobalValue *GV) {
return MachinePointerInfo(MF.getPSVManager().getGlobalValueCallEntry(GV));
}
int MipsFunctionInfo::getMoveF64ViaSpillFI(const TargetRegisterClass *RC) {

35
lib/Target/Mips/MipsMachineFunction.h
View File

@ -15,12 +15,10 @@
#define LLVM_LIB_TARGET_MIPS_MIPSMACHINEFUNCTION_H
#include "Mips16HardFloatInfo.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineMemOperand.h"
#include "llvm/CodeGen/PseudoSourceValue.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/ValueMap.h"
#include "llvm/Target/TargetFrameLowering.h"
#include "llvm/Target/TargetMachine.h"
@ -30,24 +28,6 @@
namespace llvm {
/// \brief A class derived from PseudoSourceValue that represents a GOT entry
/// resolved by lazy-binding.
class MipsCallEntry : public PseudoSourceValue {
public:
explicit MipsCallEntry(StringRef N);
explicit MipsCallEntry(const GlobalValue *V);
bool isConstant(const MachineFrameInfo *) const override;
bool isAliased(const MachineFrameInfo *) const override;
bool mayAlias(const MachineFrameInfo *) const override;
private:
void printCustom(raw_ostream &O) const override;
#ifndef NDEBUG
std::string Name;
const GlobalValue *Val;
#endif
};
/// MipsFunctionInfo - This class is derived from MachineFunction private
/// Mips target-specific information for each MachineFunction.
class MipsFunctionInfo : public MachineFunctionInfo {
@ -86,13 +66,13 @@ public:
int getEhDataRegFI(unsigned Reg) const { return EhDataRegFI[Reg]; }
bool isEhDataRegFI(int FI) const;
/// \brief Create a MachinePointerInfo that has a MipsCallEntr object
/// representing a GOT entry for an external function.
MachinePointerInfo callPtrInfo(StringRef Name);
/// Create a MachinePointerInfo that has an ExternalSymbolPseudoSourceValue
/// object representing a GOT entry for an external function.
MachinePointerInfo callPtrInfo(const char *ES);
/// \brief Create a MachinePointerInfo that has a MipsCallEntr object
/// Create a MachinePointerInfo that has a GlobalValuePseudoSourceValue object
/// representing a GOT entry for a global function.
MachinePointerInfo callPtrInfo(const GlobalValue *Val);
MachinePointerInfo callPtrInfo(const GlobalValue *GV);
void setSaveS2() { SaveS2 = true; }
bool hasSaveS2() const { return SaveS2; }
@ -142,11 +122,6 @@ private:
/// FrameIndex for expanding BuildPairF64 nodes to spill and reload when the
/// O32 FPXX ABI is enabled. -1 is used to denote invalid index.
int MoveF64ViaSpillFI;
/// MipsCallEntry maps.
StringMap<std::unique_ptr<const MipsCallEntry>> ExternalCallEntries;
ValueMap<const GlobalValue *, std::unique_ptr<const MipsCallEntry>>
GlobalCallEntries;
};
} // end of namespace llvm