Improve conformance with the Misha spelling benchmark suite

llvm-svn: 19930

llvm/include/llvm/ADT/ilist

@@ -60,8 +60,8 @@ struct ilist_traits {
 
   static NodeTy *createNode(const NodeTy &V) { return new NodeTy(V); }
 
-  static NodeTy *createSentinal() { return new NodeTy(); }
-  static void destroySentinal(NodeTy *N) { delete N; }
+  static NodeTy *createSentinel() { return new NodeTy(); }
+  static void destroySentinel(NodeTy *N) { delete N; }
 
   void addNodeToList(NodeTy *NTy) {}
   void removeNodeFromList(NodeTy *NTy) {}
@@ -302,11 +302,11 @@ public:
   typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
   typedef std::reverse_iterator<iterator>  reverse_iterator;
 
-  iplist() : Head(Traits::createSentinal()), Tail(Head) {
+  iplist() : Head(Traits::createSentinel()), Tail(Head) {
     setNext(Head, 0);
     setPrev(Head, 0);
   }
-  ~iplist() { clear(); Traits::destroySentinal(Tail); }
+  ~iplist() { clear(); Traits::destroySentinel(Tail); }
 
   // Iterator creation methods.
   iterator begin()             { return iterator(Head); }

llvm/include/llvm/Analysis/DataStructure/DSNode.h

@@ -369,8 +369,8 @@ struct ilist_traits<DSNode> {
   static void setPrev(DSNode *N, DSNode *Prev) { N->Prev = Prev; }
   static void setNext(DSNode *N, DSNode *Next) { N->Next = Next; }
 
-  static DSNode *createSentinal() { return new DSNode(0,0); }
-  static void destroySentinal(DSNode *N) { delete N; }
+  static DSNode *createSentinel() { return new DSNode(0,0); }
+  static void destroySentinel(DSNode *N) { delete N; }
   //static DSNode *createNode(const DSNode &V) { return new DSNode(V); }
 
 

llvm/include/llvm/BasicBlock.h

@@ -40,9 +40,9 @@ template <class Ptr, class USE_iterator> class PredIterator;
 
 template<> struct ilist_traits<Instruction>
   : public SymbolTableListTraits<Instruction, BasicBlock, Function> {
-  // createSentinal is used to create a node that marks the end of the list...
-  static Instruction *createSentinal();
-  static void destroySentinal(Instruction *I) { delete I; }
+  // createSentinel is used to create a node that marks the end of the list...
+  static Instruction *createSentinel();
+  static void destroySentinel(Instruction *I) { delete I; }
   static iplist<Instruction> &getList(BasicBlock *BB);
 };
 

llvm/include/llvm/Function.h

@@ -31,18 +31,18 @@ class FunctionType;
 template<> struct ilist_traits<BasicBlock>
   : public SymbolTableListTraits<BasicBlock, Function, Function> {
 
-  // createSentinal is used to create a node that marks the end of the list...
-  static BasicBlock *createSentinal();
-  static void destroySentinal(BasicBlock *BB) { delete BB; }
+  // createSentinel is used to create a node that marks the end of the list...
+  static BasicBlock *createSentinel();
+  static void destroySentinel(BasicBlock *BB) { delete BB; }
   static iplist<BasicBlock> &getList(Function *F);
 };
 
 template<> struct ilist_traits<Argument>
   : public SymbolTableListTraits<Argument, Function, Function> {
 
-  // createSentinal is used to create a node that marks the end of the list...
-  static Argument *createSentinal();
-  static void destroySentinal(Argument *A) { delete A; }
+  // createSentinel is used to create a node that marks the end of the list...
+  static Argument *createSentinel();
+  static void destroySentinel(Argument *A) { delete A; }
   static iplist<Argument> &getList(Function *F);
 };
 

llvm/include/llvm/Module.h

@@ -32,16 +32,16 @@ class SymbolTable;
 
 template<> struct ilist_traits<Function>
   : public SymbolTableListTraits<Function, Module, Module> {
-  // createSentinal is used to create a node that marks the end of the list.
-  static Function *createSentinal();
-  static void destroySentinal(Function *F) { delete F; }
+  // createSentinel is used to create a node that marks the end of the list.
+  static Function *createSentinel();
+  static void destroySentinel(Function *F) { delete F; }
   static iplist<Function> &getList(Module *M);
 };
 template<> struct ilist_traits<GlobalVariable>
   : public SymbolTableListTraits<GlobalVariable, Module, Module> {
-  // createSentinal is used to create a node that marks the end of the list.
-  static GlobalVariable *createSentinal();
-  static void destroySentinal(GlobalVariable *GV) { delete GV; }
+  // createSentinel is used to create a node that marks the end of the list.
+  static GlobalVariable *createSentinel();
+  static void destroySentinel(GlobalVariable *GV) { delete GV; }
   static iplist<GlobalVariable> &getList(Module *M);
 };
 

llvm/include/llvm/Use.h

@@ -84,12 +84,12 @@ struct ilist_traits<Use> {
   static void setPrev(Use *N, Use *Prev) { N->UseLinks.Prev = Prev; }
   static void setNext(Use *N, Use *Next) { N->UseLinks.Next = Next; }
 
-  /// createSentinal - this is used to create the end marker for the use list.
+  /// createSentinel - this is used to create the end marker for the use list.
   /// Note that we only allocate a UseLinks structure, which is just enough to
   /// hold the next/prev pointers.  This saves us 8 bytes of memory for every
   /// Value allocated.
-  static Use *createSentinal() { return (Use*)new Use::NextPrevPtrs(); }
-  static void destroySentinal(Use *S) { delete (Use::NextPrevPtrs*)S; }
+  static Use *createSentinel() { return (Use*)new Use::NextPrevPtrs(); }
+  static void destroySentinel(Use *S) { delete (Use::NextPrevPtrs*)S; }
 
   void addNodeToList(Use *NTy) {}
   void removeNodeFromList(Use *NTy) {}

llvm/lib/CodeGen/MachineBasicBlock.cpp

@@ -46,7 +46,7 @@ void ilist_traits<MachineBasicBlock>::removeNodeFromList(MachineBasicBlock* N) {
 }
 
 
-MachineInstr* ilist_traits<MachineInstr>::createSentinal() {
+MachineInstr* ilist_traits<MachineInstr>::createSentinel() {
   MachineInstr* dummy = new MachineInstr(0, 0);
   LeakDetector::removeGarbageObject(dummy);
   return dummy;

llvm/lib/CodeGen/MachineFunction.cpp

@@ -90,7 +90,7 @@ FunctionPass *llvm::createMachineCodeDeleter() {
 // MachineFunction implementation
 //===---------------------------------------------------------------------===//
 
-MachineBasicBlock* ilist_traits<MachineBasicBlock>::createSentinal() {
+MachineBasicBlock* ilist_traits<MachineBasicBlock>::createSentinel() {
   MachineBasicBlock* dummy = new MachineBasicBlock();
   LeakDetector::removeGarbageObject(dummy);
   return dummy;

llvm/lib/VMCore/BasicBlock.cpp

@@ -48,7 +48,7 @@ namespace {
   };
 }
 
-Instruction *ilist_traits<Instruction>::createSentinal() {
+Instruction *ilist_traits<Instruction>::createSentinel() {
   return new DummyInst();
 }
 iplist<Instruction> &ilist_traits<Instruction>::getList(BasicBlock *BB) {

llvm/lib/VMCore/Function.cpp

@@ -20,7 +20,7 @@
 #include "llvm/ADT/StringExtras.h"
 using namespace llvm;
 
-BasicBlock *ilist_traits<BasicBlock>::createSentinal() {
+BasicBlock *ilist_traits<BasicBlock>::createSentinel() {
   BasicBlock *Ret = new BasicBlock();
   // This should not be garbage monitored.
   LeakDetector::removeGarbageObject(Ret);
@@ -31,7 +31,7 @@ iplist<BasicBlock> &ilist_traits<BasicBlock>::getList(Function *F) {
   return F->getBasicBlockList();
 }
 
-Argument *ilist_traits<Argument>::createSentinal() {
+Argument *ilist_traits<Argument>::createSentinel() {
   Argument *Ret = new Argument(Type::IntTy);
   // This should not be garbage monitored.
   LeakDetector::removeGarbageObject(Ret);

llvm/lib/VMCore/Module.cpp

@@ -28,7 +28,7 @@ using namespace llvm;
 // Methods to implement the globals and functions lists.
 //
 
-Function *ilist_traits<Function>::createSentinal() {
+Function *ilist_traits<Function>::createSentinel() {
   FunctionType *FTy =
     FunctionType::get(Type::VoidTy, std::vector<const Type*>(), false);
   Function *Ret = new Function(FTy, GlobalValue::ExternalLinkage);
@@ -36,7 +36,7 @@ Function *ilist_traits<Function>::createSentinal() {
   LeakDetector::removeGarbageObject(Ret);
   return Ret;
 }
-GlobalVariable *ilist_traits<GlobalVariable>::createSentinal() {
+GlobalVariable *ilist_traits<GlobalVariable>::createSentinel() {
   GlobalVariable *Ret = new GlobalVariable(Type::IntTy, false,
                                            GlobalValue::ExternalLinkage);
   // This should not be garbage monitored.