From 60ae8c800ad711ef05f6d51b7953de4c1381ca07 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Tue, 11 Aug 2015 22:17:22 +0000 Subject: [PATCH] Reformat PseudoSourceValue.cpp and PseudoSourceValue.h. NFC. This commit reformats the files lib/CodeGen/PseudoSourceValue.cpp and include/llvm/CodeGen/PseudoSourceValue.h using clang-format. This change is done in preparation for the changes to the pseudo source value object management and to the PseudoSourceValue's class hierarchy. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@244685 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/PseudoSourceValue.h | 135 ++++++++++++----------- lib/CodeGen/PseudoSourceValue.cpp | 51 ++++----- 2 files changed, 92 insertions(+), 94 deletions(-) diff --git a/include/llvm/CodeGen/PseudoSourceValue.h b/include/llvm/CodeGen/PseudoSourceValue.h index a518b623325..e97cea3810f 100644 --- a/include/llvm/CodeGen/PseudoSourceValue.h +++ b/include/llvm/CodeGen/PseudoSourceValue.h @@ -17,94 +17,95 @@ #include "llvm/IR/Value.h" namespace llvm { - class MachineFrameInfo; - class MachineMemOperand; - class raw_ostream; +class MachineFrameInfo; +class MachineMemOperand; +class raw_ostream; - raw_ostream &operator<<(raw_ostream &OS, const MachineMemOperand &MMO); +raw_ostream &operator<<(raw_ostream &OS, const MachineMemOperand &MMO); - /// PseudoSourceValue - 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 { - private: - friend class MachineMemOperand; // For printCustom(). +/// PseudoSourceValue - 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 { +private: + friend class MachineMemOperand; // For printCustom(). - /// printCustom - Implement printing for PseudoSourceValue. This is called - /// from Value::print or Value's operator<<. - /// - virtual void printCustom(raw_ostream &O) const; + /// printCustom - Implement printing for PseudoSourceValue. This is called + /// from Value::print or Value's operator<<. + /// + virtual void printCustom(raw_ostream &O) const; - public: - /// isFixed - Whether this is a FixedStackPseudoSourceValue. - bool isFixed; +public: + /// isFixed - Whether this is a FixedStackPseudoSourceValue. + bool isFixed; - explicit PseudoSourceValue(bool isFixed = false); + explicit PseudoSourceValue(bool isFixed = false); - virtual ~PseudoSourceValue(); + virtual ~PseudoSourceValue(); - /// isConstant - Test whether the memory pointed to by this - /// PseudoSourceValue has a constant value. - /// - virtual bool isConstant(const MachineFrameInfo *) const; + /// isConstant - Test whether the memory pointed to by this + /// PseudoSourceValue has a constant value. + /// + virtual bool isConstant(const MachineFrameInfo *) const; - /// isAliased - 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; + /// isAliased - 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; - /// mayAlias - Return true if the memory pointed to by this - /// PseudoSourceValue can ever alias an LLVM IR Value. - virtual bool mayAlias(const MachineFrameInfo *) const; + /// mayAlias - Return true if the memory pointed to by this + /// PseudoSourceValue can ever alias an LLVM IR Value. + virtual bool mayAlias(const MachineFrameInfo *) const; - /// A pseudo source value referencing a fixed stack frame entry, - /// e.g., a spill slot. - static const PseudoSourceValue *getFixedStack(int FI); + /// A pseudo source value referencing a fixed stack frame entry, + /// e.g., a spill slot. + static const PseudoSourceValue *getFixedStack(int FI); - /// A pseudo source value referencing the area below the stack frame of - /// a function, e.g., the argument space. - static const PseudoSourceValue *getStack(); + /// A pseudo source value referencing the area below the stack frame of + /// a function, e.g., the argument space. + static const PseudoSourceValue *getStack(); - /// A pseudo source value referencing the global offset table - /// (or something the like). - static const PseudoSourceValue *getGOT(); + /// A pseudo source value referencing the global offset table + /// (or something the like). + static const PseudoSourceValue *getGOT(); - /// A pseudo source value referencing the constant pool. Since constant - /// pools are constant, this doesn't need to identify a specific constant - /// pool entry. - static const PseudoSourceValue *getConstantPool(); + /// A pseudo source value referencing the constant pool. Since constant + /// pools are constant, this doesn't need to identify a specific constant + /// pool entry. + static const PseudoSourceValue *getConstantPool(); - /// A pseudo source value referencing a jump table. Since jump tables are - /// constant, this doesn't need to identify a specific jump table. - static const PseudoSourceValue *getJumpTable(); - }; + /// A pseudo source value referencing a jump table. Since jump tables are + /// constant, this doesn't need to identify a specific jump table. + static const PseudoSourceValue *getJumpTable(); +}; - /// FixedStackPseudoSourceValue - 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(true), FI(fi) {} +/// FixedStackPseudoSourceValue - A specialized PseudoSourceValue +/// for holding FixedStack values, which must include a frame +/// index. +class FixedStackPseudoSourceValue : public PseudoSourceValue { + const int FI; - /// classof - Methods for support type inquiry through isa, cast, and - /// dyn_cast: - /// - static inline bool classof(const PseudoSourceValue *V) { - return V->isFixed == true; - } +public: + explicit FixedStackPseudoSourceValue(int fi) + : PseudoSourceValue(true), FI(fi) {} - bool isConstant(const MachineFrameInfo *MFI) const override; + /// classof - Methods for support type inquiry through isa, cast, and + /// dyn_cast: + /// + static inline bool classof(const PseudoSourceValue *V) { + return V->isFixed == true; + } - bool isAliased(const MachineFrameInfo *MFI) const override; + bool isConstant(const MachineFrameInfo *MFI) const override; - bool mayAlias(const MachineFrameInfo *) const override; + bool isAliased(const MachineFrameInfo *MFI) const override; - void printCustom(raw_ostream &OS) const override; + bool mayAlias(const MachineFrameInfo *) const override; - int getFrameIndex() const { return FI; } - }; + void printCustom(raw_ostream &OS) const override; + + int getFrameIndex() const { return FI; } +}; } // End llvm namespace #endif diff --git a/lib/CodeGen/PseudoSourceValue.cpp b/lib/CodeGen/PseudoSourceValue.cpp index b1c341d3a68..5c9bec9aa0e 100644 --- a/lib/CodeGen/PseudoSourceValue.cpp +++ b/lib/CodeGen/PseudoSourceValue.cpp @@ -26,13 +26,15 @@ namespace { struct PSVGlobalsTy { // PseudoSourceValues are immutable so don't need locking. const PseudoSourceValue PSVs[4]; - sys::Mutex Lock; // Guards FSValues, but not the values inside it. + sys::Mutex Lock; // Guards FSValues, but not the values inside it. std::map FSValues; PSVGlobalsTy() : PSVs() {} ~PSVGlobalsTy() { for (std::map::iterator - I = FSValues.begin(), E = FSValues.end(); I != E; ++I) { + I = FSValues.begin(), + E = FSValues.end(); + I != E; ++I) { delete I->second; } } @@ -40,23 +42,23 @@ struct PSVGlobalsTy { static ManagedStatic PSVGlobals; -} // anonymous namespace +} // anonymous namespace -const PseudoSourceValue *PseudoSourceValue::getStack() -{ return &PSVGlobals->PSVs[0]; } -const PseudoSourceValue *PseudoSourceValue::getGOT() -{ return &PSVGlobals->PSVs[1]; } -const PseudoSourceValue *PseudoSourceValue::getJumpTable() -{ return &PSVGlobals->PSVs[2]; } -const PseudoSourceValue *PseudoSourceValue::getConstantPool() -{ return &PSVGlobals->PSVs[3]; } +const PseudoSourceValue *PseudoSourceValue::getStack() { + return &PSVGlobals->PSVs[0]; +} +const PseudoSourceValue *PseudoSourceValue::getGOT() { + return &PSVGlobals->PSVs[1]; +} +const PseudoSourceValue *PseudoSourceValue::getJumpTable() { + return &PSVGlobals->PSVs[2]; +} +const PseudoSourceValue *PseudoSourceValue::getConstantPool() { + return &PSVGlobals->PSVs[3]; +} -static const char *const PSVNames[] = { - "Stack", - "GOT", - "JumpTable", - "ConstantPool" -}; +static const char *const PSVNames[] = {"Stack", "GOT", "JumpTable", + "ConstantPool"}; PseudoSourceValue::PseudoSourceValue(bool isFixed) : isFixed(isFixed) {} @@ -78,31 +80,26 @@ const PseudoSourceValue *PseudoSourceValue::getFixedStack(int FI) { bool PseudoSourceValue::isConstant(const MachineFrameInfo *) const { if (this == getStack()) return false; - if (this == getGOT() || - this == getConstantPool() || - this == getJumpTable()) + if (this == getGOT() || this == getConstantPool() || this == getJumpTable()) return true; llvm_unreachable("Unknown PseudoSourceValue!"); } bool PseudoSourceValue::isAliased(const MachineFrameInfo *MFI) const { - if (this == getStack() || - this == getGOT() || - this == getConstantPool() || + if (this == getStack() || this == getGOT() || this == getConstantPool() || this == getJumpTable()) return false; llvm_unreachable("Unknown PseudoSourceValue!"); } bool PseudoSourceValue::mayAlias(const MachineFrameInfo *MFI) const { - if (this == getGOT() || - this == getConstantPool() || - this == getJumpTable()) + if (this == getGOT() || this == getConstantPool() || this == getJumpTable()) return false; return true; } -bool FixedStackPseudoSourceValue::isConstant(const MachineFrameInfo *MFI) const{ +bool FixedStackPseudoSourceValue::isConstant( + const MachineFrameInfo *MFI) const { return MFI && MFI->isImmutableObjectIndex(FI); }