X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FLLVMContext.h;h=5ec33453db6b6168969dc81142c5aa66076f89b2;hb=4b938958bcc59586508bc9681e75c2e3f5164672;hp=e441d189c2f65a34b619e9310caa8a91c4851e8d;hpb=0a5372ed3e8cda10d724feda3c1a1c998db05ca0;p=oota-llvm.git

diff --git a/include/llvm/LLVMContext.h b/include/llvm/LLVMContext.h
index e441d189c2f..5ec33453db6 100644
--- a/include/llvm/LLVMContext.h
+++ b/include/llvm/LLVMContext.h
@@ -58,22 +58,48 @@ public:
   
   // Constant accessors
   Constant* getNullValue(const Type* Ty);
+  
+  /// @returns the value for an integer constant of the given type that has all
+  /// its bits set to true.
+  /// @brief Get the all ones value
   Constant* getAllOnesValue(const Type* Ty);
   
   // UndefValue accessors
   UndefValue* getUndef(const Type* Ty);
   
   // ConstantInt accessors
-  ConstantInt* getConstantIntTrue();
-  ConstantInt* getConstantIntFalse();
+  ConstantInt* getTrue();
+  ConstantInt* getFalse();
+  
+  /// If Ty is a vector type, return a Constant with a splat of the given
+  /// value. Otherwise return a ConstantInt for the given value.
   Constant* getConstantInt(const Type* Ty, uint64_t V,
                               bool isSigned = false);
+                              
+  /// Return a ConstantInt with the specified integer value for the specified
+  /// type. If the type is wider than 64 bits, the value will be zero-extended
+  /// to fit the type, unless isSigned is true, in which case the value will
+  /// be interpreted as a 64-bit signed integer and sign-extended to fit
+  /// the type.
+  /// @brief Get a ConstantInt for a specific value.
   ConstantInt* getConstantInt(const IntegerType* Ty, uint64_t V,
                               bool isSigned = false);
+
+  /// Return a ConstantInt with the specified value for the specified type. The
+  /// value V will be canonicalized to a an unsigned APInt. Accessing it with
+  /// either getSExtValue() or getZExtValue() will yield a correctly sized and
+  /// signed value for the type Ty.
+  /// @brief Get a ConstantInt for a specific signed value.
   ConstantInt* getConstantIntSigned(const IntegerType* Ty, int64_t V);
+  Constant *getConstantIntSigned(const Type *Ty, int64_t V);
+  
+  /// Return a ConstantInt with the specified value and an implied Type. The
+  /// type is the integer type that corresponds to the bit width of the value.
   ConstantInt* getConstantInt(const APInt& V);
+  
+  /// If Ty is a vector type, return a Constant with a splat of the given
+  /// value. Otherwise return a ConstantInt for the given value.
   Constant* getConstantInt(const Type* Ty, const APInt& V);
-  ConstantInt* getConstantIntAllOnesValue(const Type* Ty);
   
   // ConstantPointerNull accessors
   ConstantPointerNull* getConstantPointerNull(const PointerType* T);
@@ -94,6 +120,13 @@ public:
                              const std::vector<Constant*>& V);
   Constant* getConstantArray(const ArrayType* T, Constant* const* Vals,
                              unsigned NumVals);
+                             
+  /// This method constructs a ConstantArray and initializes it with a text
+  /// string. The default behavior (AddNull==true) causes a null terminator to
+  /// be placed at the end of the array. This effectively increases the length
+  /// of the array by one (you've been warned).  However, in some situations 
+  /// this is not desired so if AddNull==false then the string is copied without
+  /// null termination.
   Constant* getConstantArray(const std::string& Initializer,
                              bool AddNull = true);
                              
@@ -180,6 +213,11 @@ public:
   
   // ConstantFP accessors
   ConstantFP* getConstantFP(const APFloat& V);
+  
+  /// get() - This returns a ConstantFP, or a vector containing a splat of a
+  /// ConstantFP, for the specified value in the specified type.  This should
+  /// only be used for simple constant values like 2.0/1.0 etc, that are
+  /// known-valid both as host double and as the target format.
   Constant* getConstantFP(const Type* Ty, double V);
   ConstantFP* getConstantFPNegativeZero(const Type* Ty);
   
@@ -188,7 +226,6 @@ public:
                               const std::vector<Constant*>& V);
   Constant* getConstantVector(const std::vector<Constant*>& V);
   Constant* getConstantVector(Constant* const* Vals, unsigned NumVals);
-  ConstantVector* getConstantVectorAllOnesValue(const VectorType* Ty);
   
   // MDNode accessors
   MDNode* getMDNode(Value* const* Vals, unsigned NumVals);
@@ -231,6 +268,10 @@ public:
   // Other helpers
   /// @brief Create a result type for fcmp/icmp
   const Type* makeCmpResultType(const Type* opnd_type);
+  
+  // Methods for erasing constants
+  void erase(MDString *M);
+  void erase(MDNode *M);
 };
 
 /// FOR BACKWARDS COMPATIBILITY - Returns a global context.