Move header ConstantFold.h into include directory

[sepavloff]

Summary

Functions in ConstantFold.h were declared as internal interface so this
header resided in lib directory. However the functions declared there
are useful in other places, in particular, in ConstantFolding.cpp. To
avoid code duplication, these functions are moved into include
directory, so the interface declared in ConstantFold.h is not internal
anymore.

This change only modes the include file, fixes references to it and
removes mentions about internal interface. No functional changes.

[RKSimon]

llvm/include/llvm/IR/ConstantFold.h

19

LLVM_IR_CONSTANTFOLD_H ?

[sepavloff]

Fixed header guard

[RKSimon]

LGTM

llvm/include/llvm/IR/ConstantFold.h

32

(style) Opcode

[sepavloff]

Thanks!

[RKSimon]

@sepavloff Are you still intending to commit this?

[sepavloff]

D110322 was remade and this change is not necessary for it anymore. But this change could be needed it we modify constant evaluation for constrained intrinsics by moving the evaluation into a separate pass.

Do you need these patch? If yes, I will commit it.

[RKSimon]

In D115035#3273092, @sepavloff wrote:

D110322 was remade and this change is not necessary for it anymore. But this change could be needed it we modify constant evaluation for constrained intrinsics by moving the evaluation into a separate pass.

Do you need these patch? If yes, I will commit it.

I was mainly triaging accepted-but-uncommited phabs in the run up to the 14.x branch, but I see no harm in committing this if you see a future use, or maybe abandon it (no pressure though!) to avoid bitrot?

[sepavloff]

In D115035#3273211, @RKSimon wrote:

In D115035#3273092, @sepavloff wrote:

D110322 was remade and this change is not necessary for it anymore. But this change could be needed it we modify constant evaluation for constrained intrinsics by moving the evaluation into a separate pass.

Do you need these patch? If yes, I will commit it.

I was mainly triaging accepted-but-uncommited phabs in the run up to the 14.x branch, but I see no harm in committing this if you see a future use, or maybe abandon it (no pressure though!) to avoid bitrot?

I created D118319, depending on review feedback destiny of this patch will be resolved in a couple of days.

[sepavloff]

Neither D110322 nor D118426 now do not depend on this patch. Although this patch can be useful in future, now it is not needed. To keep records clean the patch is abandoned.

llvm/include/llvm/IR/ConstantFold.h

+//===-- ConstantFold.h --- Constant Folding Interface -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the constant folding interfaces for LLVM.  These
+// interfaces are used by the ConstantExpr::get* methods to automatically fold
+// constants when possible.
+//
+// These operators may return a null object if they don't know how to perform
+// the specified operation on the specified constant types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_IR_CONSTANTFOLD_H
+#define LLVM_LIB_IR_CONSTANTFOLD_H
+
+#include "llvm/ADT/Optional.h"
+
+namespace llvm {
+template <typename T> class ArrayRef;
+class Value;
+class Constant;
+class Type;
+
+// Constant fold various types of instruction...
+Constant *
+ConstantFoldCastInstruction(unsigned opcode, ///< The opcode of the cast
+                            Constant *V,     ///< The source constant
+                            Type *DestTy     ///< The destination type
+);
+Constant *ConstantFoldSelectInstruction(Constant *Cond, Constant *V1,
+                                        Constant *V2);
+Constant *ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx);
+Constant *ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt,
+                                               Constant *Idx);
+Constant *ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2,
+                                               ArrayRef<int> Mask);
+Constant *ConstantFoldExtractValueInstruction(Constant *Agg,
+                                              ArrayRef<unsigned> Idxs);
+Constant *ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val,
+                                             ArrayRef<unsigned> Idxs);
+Constant *ConstantFoldUnaryInstruction(unsigned Opcode, Constant *V);
+Constant *ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1,
+                                        Constant *V2);
+Constant *ConstantFoldCompareInstruction(unsigned short predicate, Constant *C1,
+                                         Constant *C2);
+Constant *ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool InBounds,
+                                    Optional<unsigned> InRangeIndex,
+                                    ArrayRef<Value *> Idxs);
+} // namespace llvm
+
+#endif

llvm/lib/IR/ConstantFold.h

-//===-- ConstantFolding.h - Internal Constant Folding Interface -*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the (internal) constant folding interfaces for LLVM.  These
-// interfaces are used by the ConstantExpr::get* methods to automatically fold
-// constants when possible.
-//
-// These operators may return a null object if they don't know how to perform
-// the specified operation on the specified constant types.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_LIB_IR_CONSTANTFOLD_H
-#define LLVM_LIB_IR_CONSTANTFOLD_H
-
-#include "llvm/ADT/Optional.h"
-
-namespace llvm {
-template <typename T> class ArrayRef;
-  class Value;
-  class Constant;
-  class Type;
-
-  // Constant fold various types of instruction...
-  Constant *ConstantFoldCastInstruction(
-    unsigned opcode,     ///< The opcode of the cast
-    Constant *V,         ///< The source constant
-    Type *DestTy   ///< The destination type
-  );
-  Constant *ConstantFoldSelectInstruction(Constant *Cond,
-                                          Constant *V1, Constant *V2);
-  Constant *ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx);
-  Constant *ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt,
-                                                 Constant *Idx);
-  Constant *ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2,
-                                                 ArrayRef<int> Mask);
-  Constant *ConstantFoldExtractValueInstruction(Constant *Agg,
-                                                ArrayRef<unsigned> Idxs);
-  Constant *ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val,
-                                               ArrayRef<unsigned> Idxs);
-  Constant *ConstantFoldUnaryInstruction(unsigned Opcode, Constant *V);
-  Constant *ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1,
-                                          Constant *V2);
-  Constant *ConstantFoldCompareInstruction(unsigned short predicate,
-                                           Constant *C1, Constant *C2);
-  Constant *ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool InBounds,
-                                      Optional<unsigned> InRangeIndex,
-                                      ArrayRef<Value *> Idxs);
-} // End llvm namespace
-
-#endif

llvm/lib/IR/ConstantFold.cpp

 //===- ConstantFold.cpp - LLVM constant folder ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements folding of constants for LLVM.  This implements the
-// (internal) ConstantFold.h interface, which is used by the
+// ConstantFold.h interface, which is used by the
 // ConstantExpr::get* methods to automatically fold constants when possible.
 //
 // The current constant folding implementation is implemented in two pieces: the
 // pieces that don't need DataLayout, and the pieces that do. This is to avoid
 // a dependence in IR on Target.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ConstantFold.h"
+#include "llvm/IR/ConstantFold.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"

llvm/lib/IR/Constants.cpp

 //===-- Constants.cpp - Implement Constant nodes --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Constant* classes.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Constants.h"
-#include "ConstantFold.h"
 #include "LLVMContextImpl.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/IR/ConstantFold.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/Support/Debug.h"