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

diff --git a/include/llvm/CodeGen/PseudoSourceValue.h b/include/llvm/CodeGen/PseudoSourceValue.h
index a518b6233250eb1a20d7fd2f25b5dc8336d73298..e97cea3810f31bb79746671567c92558f5e0eb41 100644 (file)
--- 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;
-
-  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().
-
-    /// 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;
-
-    explicit PseudoSourceValue(bool isFixed = false);
-
-    virtual ~PseudoSourceValue();
-
-    /// 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;
-
-    /// 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 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 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();
-  };
-
-  /// 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) {}
-
-    /// classof - Methods for support type inquiry through isa, cast, and
-    /// dyn_cast:
-    ///
-    static inline bool classof(const PseudoSourceValue *V) {
-      return V->isFixed == true;
-    }
-
-    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 MachineFrameInfo;
+class MachineMemOperand;
+class raw_ostream;
+
+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().
+
+  /// 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;
+
+  explicit PseudoSourceValue(bool isFixed = false);
+
+  virtual ~PseudoSourceValue();
+
+  /// 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;
+
+  /// 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 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 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();
+};
+
+/// 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) {}
+
+  /// classof - Methods for support type inquiry through isa, cast, and
+  /// dyn_cast:
+  ///
+  static inline bool classof(const PseudoSourceValue *V) {
+    return V->isFixed == true;
+  }
+
+  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; }
+};
 } // End llvm namespace
 
 #endif

diff --git a/lib/CodeGen/PseudoSourceValue.cpp b/lib/CodeGen/PseudoSourceValue.cpp
index b1c341d3a681bd414f6ec53ee6ab7cff03dde700..5c9bec9aa0e94a27f4e440586be298891e3899e0 100644 (file)
--- 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<int, const PseudoSourceValue *> FSValues;
 
   PSVGlobalsTy() : PSVs() {}
   ~PSVGlobalsTy() {
     for (std::map<int, const PseudoSourceValue *>::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<PSVGlobalsTy> PSVGlobals;
 
-}  // 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]; }
-
-static const char *const PSVNames[] = {
-  "Stack",
-  "GOT",
-  "JumpTable",
-  "ConstantPool"
-};
+} // 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];
+}
+
+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);
 }