From 4e3b446ae875799f3ded6cddc4768028136d1ee9 Mon Sep 17 00:00:00 2001
From: Manuel Jacob <me@manueljacob.de>
Date: Wed, 20 Jan 2016 22:27:06 +0000
Subject: [PATCH] Run clang-format over ConstantFolding.h, fixing inconsistent
 indentation.  NFC.

llvm-svn: 258361
---
 llvm/include/llvm/Analysis/ConstantFolding.h | 45 ++++++++++----------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/llvm/include/llvm/Analysis/ConstantFolding.h b/llvm/include/llvm/Analysis/ConstantFolding.h
index e8185b3b6307..f3415017e027 100644
--- a/llvm/include/llvm/Analysis/ConstantFolding.h
+++ b/llvm/include/llvm/Analysis/ConstantFolding.h
@@ -21,30 +21,29 @@
 #define LLVM_ANALYSIS_CONSTANTFOLDING_H
 
 namespace llvm {
-  class Constant;
-  class ConstantExpr;
-  class Instruction;
-  class DataLayout;
-  class TargetLibraryInfo;
-  class Function;
-  class Type;
-  template<typename T>
-  class ArrayRef;
+class Constant;
+class ConstantExpr;
+class Instruction;
+class DataLayout;
+class TargetLibraryInfo;
+class Function;
+class Type;
+template <typename T> class ArrayRef;
 
 /// ConstantFoldInstruction - Try to constant fold the specified instruction.
 /// If successful, the constant result is returned, if not, null is returned.
 /// Note that this fails if not all of the operands are constant.  Otherwise,
 /// this function can only fail when attempting to fold instructions like loads
 /// and stores, which have no constant expression form.
-  Constant *ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
-                                    const TargetLibraryInfo *TLI = nullptr);
+Constant *ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
+                                  const TargetLibraryInfo *TLI = nullptr);
 
 /// ConstantFoldConstantExpression - Attempt to fold the constant expression
 /// using the specified DataLayout.  If successful, the constant result is
 /// result is returned, if not, null is returned.
-  Constant *
-  ConstantFoldConstantExpression(const ConstantExpr *CE, const DataLayout &DL,
-                                 const TargetLibraryInfo *TLI = nullptr);
+Constant *
+ConstantFoldConstantExpression(const ConstantExpr *CE, const DataLayout &DL,
+                               const TargetLibraryInfo *TLI = nullptr);
 
 /// ConstantFoldInstOperands - Attempt to constant fold an instruction with the
 /// specified operands.  If successful, the constant result is returned, if not,
@@ -52,19 +51,19 @@ namespace llvm {
 /// fold instructions like loads and stores, which have no constant expression
 /// form.
 ///
-  Constant *ConstantFoldInstOperands(unsigned Opcode, Type *DestTy,
-                                     ArrayRef<Constant *> Ops,
-                                     const DataLayout &DL,
-                                     const TargetLibraryInfo *TLI = nullptr);
+Constant *ConstantFoldInstOperands(unsigned Opcode, Type *DestTy,
+                                   ArrayRef<Constant *> Ops,
+                                   const DataLayout &DL,
+                                   const TargetLibraryInfo *TLI = nullptr);
 
 /// ConstantFoldCompareInstOperands - Attempt to constant fold a compare
 /// instruction (icmp/fcmp) with the specified operands.  If it fails, it
 /// returns a constant expression of the specified operands.
 ///
-  Constant *
-  ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS,
-                                  Constant *RHS, const DataLayout &DL,
-                                  const TargetLibraryInfo *TLI = nullptr);
+Constant *
+ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS,
+                                Constant *RHS, const DataLayout &DL,
+                                const TargetLibraryInfo *TLI = nullptr);
 
 /// ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue
 /// instruction with the specified operands and indices.  The constant result is
@@ -98,7 +97,7 @@ Constant *ConstantFoldLoadThroughGEPConstantExpr(Constant *C, ConstantExpr *CE);
 /// return the constant value being addressed by a virtual load, or null if
 /// something is funny and we can't decide.
 Constant *ConstantFoldLoadThroughGEPIndices(Constant *C,
-                                            ArrayRef<Constant*> Indices);
+                                            ArrayRef<Constant *> Indices);
 
 /// canConstantFoldCallTo - Return true if its even possible to fold a call to
 /// the specified function.