Begin the painful process of tearing apart the rat'ss nest that is Constants.cpp and ConstantFold.cpp.

This involves temporarily hard wiring some parts to use the global context.  This isn't ideal, but it's
the only way I could figure out to make this process vaguely incremental.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@75445 91177308-0d34-0410-b5e6-96231b3b80d8

6 files changed, 31 insertions, 35 deletions

diff --git a/include/llvm/CodeGen/FastISel.h b/include/llvm/CodeGen/FastISel.h
index c7b1a42..857267c 100644
--- a/include/llvm/CodeGen/FastISel.h
+++ b/include/llvm/CodeGen/FastISel.h
@@ -60,6 +60,7 @@ protected:
   const TargetData &TD;
   const TargetInstrInfo &TII;
   const TargetLowering &TLI;
+  LLVMContext *Context;
 
 public:
   /// startNewBlock - Set the current block to which generated machine
diff --git a/include/llvm/Constant.h b/include/llvm/Constant.h
index d4949d1..05a6623 100644
--- a/include/llvm/Constant.h
+++ b/include/llvm/Constant.h
@@ -18,6 +18,7 @@
 
 namespace llvm {
   template<typename T> class SmallVectorImpl;
+  class LLVMContext;
 
   /// If object contains references to other objects, then relocations are
   /// usually required for emission of such object (especially in PIC mode). One
@@ -59,10 +60,6 @@ protected:
 
   void destroyConstantImpl();
 public:
-  /// Static constructor to get a '0' constant of arbitrary type...
-  ///
-  static Constant *getNullValue(const Type *Ty);
-
   /// Static constructor to get a '-1' constant.  This supports integers and
   /// vectors.
   ///
@@ -98,7 +95,8 @@ public:
   /// type, returns the elements of the vector in the specified smallvector.
   /// This handles breaking down a vector undef into undef elements, etc.  For
   /// constant exprs and other cases we can't handle, we return an empty vector.
-  void getVectorElements(SmallVectorImpl<Constant*> &Elts) const;
+  void getVectorElements(LLVMContext &Context, 
+                         SmallVectorImpl<Constant*> &Elts) const;
 
   /// destroyConstant - Called if some element of this constant is no longer
   /// valid.  At this point only other constants may be on the use_list for this
diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index 0975066..77124d8 100644
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -276,9 +276,6 @@ public:
   /// considers -0.0 to be null as well as 0.0.  :(
   virtual bool isNullValue() const;
 
-  // Get a negative zero.
-  static ConstantFP *getNegativeZero(const Type* Ty);
-
   /// isExactlyValue - We don't rely on operator== working on double values, as
   /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
   /// As such, this method can be used to do an exact bit-for-bit comparison of
@@ -383,7 +380,7 @@ public:
   /// isString) and it ends in a null byte \0 and does not contains any other
   /// @endverbatim
   /// null bytes except its terminator.
-  bool isCString() const;
+  bool isCString(LLVMContext &Context) const;
 
   /// getAsString - If this array is isString(), then this method converts the
   /// array to an std::string and returns it.  Otherwise, it asserts out.
@@ -694,17 +691,6 @@ public:
     return getSelectTy(V1->getType(), C, V1, V2);
   }
 
-  /// getAlignOf constant expr - computes the alignment of a type in a target
-  /// independent way (Note: the return type is an i32; Note: assumes that i8
-  /// is byte aligned).
-  ///
-  static Constant *getAlignOf(const Type *Ty);
-
-  /// getSizeOf constant expr - computes the size of a type in a target
-  /// independent way (Note: the return type is an i64).
-  ///
-  static Constant *getSizeOf(const Type *Ty);
-
   /// ConstantExpr::get - Return a binary or shift operator constant expression,
   /// folding if possible.
   ///
@@ -716,8 +702,6 @@ public:
   /// ConstantExpr::get* - Return some common constants without having to
   /// specify the full Instruction::OPCODE identifier.
   ///
-  static Constant *getNeg(Constant *C);
-  static Constant *getFNeg(Constant *C);
   static Constant *getNot(Constant *C);
   static Constant *getAdd(Constant *C1, Constant *C2);
   static Constant *getFAdd(Constant *C1, Constant *C2);
@@ -756,11 +740,6 @@ public:
   static Constant *getInsertValue(Constant *Agg, Constant *Val,
                                   const unsigned *IdxList, unsigned NumIdx);
 
-  /// Floating point negation must be implemented with f(x) = -0.0 - x. This
-  /// method returns the negative zero constant for floating point or vector
-  /// floating point types; for all other types, it returns the null value.
-  static Constant *getZeroValueForNegationExpr(const Type *Ty);
-
   /// isNullValue - Return true if this is the value that would be returned by
   /// getNullValue.
   virtual bool isNullValue() const { return false; }
diff --git a/include/llvm/InstrTypes.h b/include/llvm/InstrTypes.h
index 7682719..9c1f8fc 100644
--- a/include/llvm/InstrTypes.h
+++ b/include/llvm/InstrTypes.h
@@ -202,13 +202,17 @@ public:
   /// CreateNeg, CreateNot - Create the NEG and NOT
   ///     instructions out of SUB and XOR instructions.
   ///
-  static BinaryOperator *CreateNeg(Value *Op, const std::string &Name = "",
+  static BinaryOperator *CreateNeg(LLVMContext &Context,
+                                   Value *Op, const std::string &Name = "",
                                    Instruction *InsertBefore = 0);
-  static BinaryOperator *CreateNeg(Value *Op, const std::string &Name,
+  static BinaryOperator *CreateNeg(LLVMContext &Context,
+                                   Value *Op, const std::string &Name,
                                    BasicBlock *InsertAtEnd);
-  static BinaryOperator *CreateFNeg(Value *Op, const std::string &Name = "",
+  static BinaryOperator *CreateFNeg(LLVMContext &Context, 
+                                    Value *Op, const std::string &Name = "",
                                     Instruction *InsertBefore = 0);
-  static BinaryOperator *CreateFNeg(Value *Op, const std::string &Name,
+  static BinaryOperator *CreateFNeg(LLVMContext &Context,
+                                    Value *Op, const std::string &Name,
                                     BasicBlock *InsertAtEnd);
   static BinaryOperator *CreateNot(Value *Op, const std::string &Name = "",
                                    Instruction *InsertBefore = 0);
@@ -218,8 +222,8 @@ public:
   /// isNeg, isFNeg, isNot - Check if the given Value is a
   /// NEG, FNeg, or NOT instruction.
   ///
-  static bool isNeg(const Value *V);
-  static bool isFNeg(const Value *V);
+  static bool isNeg(LLVMContext &Context, const Value *V);
+  static bool isFNeg(LLVMContext &Context, const Value *V);
   static bool isNot(const Value *V);
 
   /// getNegArgument, getNotArgument - Helper functions to extract the
diff --git a/include/llvm/LLVMContext.h b/include/llvm/LLVMContext.h
index 75b7e59..e441d18 100644
--- a/include/llvm/LLVMContext.h
+++ b/include/llvm/LLVMContext.h
@@ -120,6 +120,11 @@ public:
                                        bool isSigned);
   Constant* getConstantExprFPCast(Constant* C, const Type* Ty);
   Constant* getConstantExprSelect(Constant* C, Constant* V1, Constant* V2);
+  
+  /// getAlignOf constant expr - computes the alignment of a type in a target
+  /// independent way (Note: the return type is an i32; Note: assumes that i8
+  /// is byte aligned).
+  ///
   Constant* getConstantExprAlignOf(const Type* Ty);
   Constant* getConstantExprCompare(unsigned short pred,
                                    Constant* C1, Constant* C2);
@@ -162,7 +167,15 @@ public:
   Constant* getConstantExprInsertValue(Constant* Agg, Constant* Val,
                                        const unsigned* IdxList,
                                        unsigned NumIdx);
+
+  /// getSizeOf constant expr - computes the size of a type in a target
+  /// independent way (Note: the return type is an i64).
+  ///
   Constant* getConstantExprSizeOf(const Type* Ty);
+  
+  /// Floating point negation must be implemented with f(x) = -0.0 - x. This
+  /// method returns the negative zero constant for floating point or vector
+  /// floating point types; for all other types, it returns the null value.
   Constant* getZeroValueForNegation(const Type* Ty);
   
   // ConstantFP accessors
@@ -200,6 +213,7 @@ public:
   StructType* getStructType(bool isPacked=false);
   StructType* getStructType(const std::vector<const Type*>& Params,
                             bool isPacked = false);
+  StructType* getStructType(const Type* type, ...);
   
   // ArrayType accessors
   ArrayType* getArrayType(const Type* ElementType, uint64_t NumElements);
diff --git a/include/llvm/Support/IRBuilder.h b/include/llvm/Support/IRBuilder.h
index 9fc29ef..5de33eb 100644
--- a/include/llvm/Support/IRBuilder.h
+++ b/include/llvm/Support/IRBuilder.h
@@ -311,12 +311,12 @@ public:
   Value *CreateNeg(Value *V, const char *Name = "") {
     if (Constant *VC = dyn_cast<Constant>(V))
       return Folder.CreateNeg(VC);
-    return Insert(BinaryOperator::CreateNeg(V), Name);
+    return Insert(BinaryOperator::CreateNeg(getGlobalContext(), V), Name);
   }
   Value *CreateFNeg(Value *V, const char *Name = "") {
     if (Constant *VC = dyn_cast<Constant>(V))
       return Folder.CreateFNeg(VC);
-    return Insert(BinaryOperator::CreateFNeg(V), Name);
+    return Insert(BinaryOperator::CreateFNeg(getGlobalContext(), V), Name);
   }
   Value *CreateNot(Value *V, const char *Name = "") {
     if (Constant *VC = dyn_cast<Constant>(V))