Never set any signal handlers.

[oota-llvm.git] / lib / Transforms / TransformInternals.h

diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h
index 9f6eb7954bc59ecb20aefccdb46bed355580b691..ac7be3a49f689aa41c1f64777ce51ef24c8c834e 100644 (file)
--- a/lib/Transforms/TransformInternals.h
+++ b/lib/Transforms/TransformInternals.h
@@ -16,9 +16,7 @@
 #include <set>
 
 static inline int64_t getConstantValue(const ConstantInt *CPI) {
-  if (const ConstantSInt *CSI = dyn_cast<ConstantSInt>(CPI))
-    return CSI->getValue();
-  return (int64_t)cast<ConstantUInt>(CPI)->getValue();
+  return (int64_t)cast<ConstantInt>(CPI)->getRawValue();
 }
 
 
@@ -30,7 +28,7 @@ static inline const CompositeType *getPointedToComposite(const Type *Ty) {
   return PT ? dyn_cast<CompositeType>(PT->getElementType()) : 0;
 }
 
-// ConvertableToGEP - This function returns true if the specified value V is
+// ConvertibleToGEP - This function returns true if the specified value V is
 // a valid index into a pointer of type Ty.  If it is valid, Idx is filled in
 // with the values that would be appropriate to make this a getelementptr
 // instruction.  The type returned is the root type that the GEP would point
@@ -39,7 +37,7 @@ static inline const CompositeType *getPointedToComposite(const Type *Ty) {
 // If BI is nonnull, cast instructions are inserted as appropriate for the
 // arguments of the getelementptr.
 //
-const Type *ConvertableToGEP(const Type *Ty, Value *V,
+const Type *ConvertibleToGEP(const Type *Ty, Value *V,
                              std::vector<Value*> &Indices,
                              const TargetData &TD,
                              BasicBlock::iterator *BI = 0);
@@ -96,7 +94,7 @@ struct ValueMapCache {
   typedef std::map<const Value *, Value *> ExprMapTy;
 
   // Cast Map - Cast instructions can have their source and destination values
-  // changed independantly for each part.  Because of this, our old naive
+  // changed independently for each part.  Because of this, our old naive
   // implementation would create a TWO new cast instructions, which would cause
   // all kinds of problems.  Here we keep track of the newly allocated casts, so
   // that we only create one for a particular instruction.
@@ -105,13 +103,13 @@ struct ValueMapCache {
 };
 
 
-bool ExpressionConvertableToType(Value *V, const Type *Ty, ValueTypeCache &Map,
+bool ExpressionConvertibleToType(Value *V, const Type *Ty, ValueTypeCache &Map,
                                  const TargetData &TD);
 Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC,
                                const TargetData &TD);
 
-// ValueConvertableToType - Return true if it is possible
-bool ValueConvertableToType(Value *V, const Type *Ty,
+// ValueConvertibleToType - Return true if it is possible
+bool ValueConvertibleToType(Value *V, const Type *Ty,
                             ValueTypeCache &ConvertedTypes,
                             const TargetData &TD);