Trailing whitespace.

[oota-llvm.git] / include / llvm / LLVMContext.h

diff --git a/include/llvm/LLVMContext.h b/include/llvm/LLVMContext.h
index e71183855a65aa3830b22b9776deb6252cc75ab9..d4cd891d8a9f802c7848b48d8446d4b4783ea887 100644 (file)
--- a/include/llvm/LLVMContext.h
+++ b/include/llvm/LLVMContext.h
@@ -70,12 +70,35 @@ public:
   // ConstantInt accessors
   ConstantInt* getConstantIntTrue();
   ConstantInt* getConstantIntFalse();
+  
+  /// 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);
   
   // ConstantPointerNull accessors
@@ -97,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);
                              
@@ -238,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.