Style update: don't duplicate the function name.

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

include/llvm/IR/Module.h

@@ -285,33 +285,33 @@ public:
 /// @name Generic Value Accessors
 /// @{
 
-  /// getNamedValue - Return the global value in the module with
+  /// Return the global value in the module with the specified name, of
-  /// the specified name, of arbitrary type.  This method returns null
+  /// arbitrary type. This method returns null if a global with the specified
-  /// if a global with the specified name is not found.
+  /// name is not found.
   GlobalValue *getNamedValue(StringRef Name) const;
 
-  /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
+  /// Return a unique non-zero ID for the specified metadata kind. This ID is
-  /// This ID is uniqued across modules in the current LLVMContext.
+  /// uniqued across modules in the current LLVMContext.
   unsigned getMDKindID(StringRef Name) const;
 
-  /// getMDKindNames - Populate client supplied SmallVector with the name for
+  /// Populate client supplied SmallVector with the name for custom metadata IDs
-  /// custom metadata IDs registered in this LLVMContext.
+  /// registered in this LLVMContext.
   void getMDKindNames(SmallVectorImpl<StringRef> &Result) const;
 
-  
+
   typedef DenseMap<StructType*, unsigned, DenseMapInfo<StructType*> >
                    NumeredTypesMapTy;
 
-  /// getTypeByName - Return the type with the specified name, or null if there
+  /// Return the type with the specified name, or null if there is none by that
-  /// is none by that name.
+  /// name.
   StructType *getTypeByName(StringRef Name) const;
 
 /// @}
 /// @name Function Accessors
 /// @{
 
-  /// getOrInsertFunction - Look up the specified function in the module symbol
+  /// Look up the specified function in the module symbol table. Four
-  /// table.  Four possibilities:
+  /// possibilities:
   ///   1. If it does not exist, add a prototype for the function and return it.
   ///   2. If it exists, and has a local linkage, the existing function is
   ///      renamed and a new one is inserted.
@@ -324,33 +324,32 @@ public:
 
   Constant *getOrInsertFunction(StringRef Name, FunctionType *T);
 
-  /// getOrInsertFunction - Look up the specified function in the module symbol
+  /// Look up the specified function in the module symbol table. If it does not
-  /// table.  If it does not exist, add a prototype for the function and return
+  /// exist, add a prototype for the function and return it. This function
-  /// it.  This function guarantees to return a constant of pointer to the
+  /// guarantees to return a constant of pointer to the specified function type
-  /// specified function type or a ConstantExpr BitCast of that type if the
+  /// or a ConstantExpr BitCast of that type if the named function has a
-  /// named function has a different type.  This version of the method takes a
+  /// different type. This version of the method takes a null terminated list of
-  /// null terminated list of function arguments, which makes it easier for
+  /// function arguments, which makes it easier for clients to use.
-  /// clients to use.
   Constant *getOrInsertFunction(StringRef Name,
                                 AttributeSet AttributeList,
                                 Type *RetTy, ...)  END_WITH_NULL;
 
-  /// getOrInsertFunction - Same as above, but without the attributes.
+  /// Same as above, but without the attributes.
   Constant *getOrInsertFunction(StringRef Name, Type *RetTy, ...)
     END_WITH_NULL;
 
-  /// getFunction - Look up the specified function in the module symbol table.
+  /// Look up the specified function in the module symbol table. If it does not
-  /// If it does not exist, return null.
+  /// exist, return null.
   Function *getFunction(StringRef Name) const;
 
 /// @}
 /// @name Global Variable Accessors
 /// @{
 
-  /// getGlobalVariable - Look up the specified global variable in the module
+  /// Look up the specified global variable in the module symbol table. If it
-  /// symbol table.  If it does not exist, return null. If AllowInternal is set
+  /// does not exist, return null. If AllowInternal is set to true, this
-  /// to true, this function will return types that have InternalLinkage. By
+  /// function will return types that have InternalLinkage. By default, these
-  /// default, these types are not returned.
+  /// types are not returned.
   const GlobalVariable *getGlobalVariable(StringRef Name,
                                           bool AllowInternal = false) const {
     return const_cast<Module *>(this)->getGlobalVariable(Name, AllowInternal);
@@ -358,9 +357,9 @@ public:
 
   GlobalVariable *getGlobalVariable(StringRef Name, bool AllowInternal = false);
 
-  /// getNamedGlobal - Return the global variable in the module with the
+  /// Return the global variable in the module with the specified name, of
-  /// specified name, of arbitrary type.  This method returns null if a global
+  /// arbitrary type. This method returns null if a global with the specified
-  /// with the specified name is not found.
+  /// name is not found.
   GlobalVariable *getNamedGlobal(StringRef Name) {
     return getGlobalVariable(Name, true);
   }
@@ -368,8 +367,7 @@ public:
     return const_cast<Module *>(this)->getNamedGlobal(Name);
   }
 
-  /// getOrInsertGlobal - Look up the specified global in the module symbol
+  /// Look up the specified global in the module symbol table.
-  /// table.
   ///   1. If it does not exist, add a declaration of the global and return it.
   ///   2. Else, the global exists but has the wrong type: return the function
   ///      with a constantexpr cast to the right type.
@@ -381,53 +379,49 @@ public:
 /// @name Global Alias Accessors
 /// @{
 
-  /// getNamedAlias - Return the global alias in the module with the
+  /// Return the global alias in the module with the specified name, of
-  /// specified name, of arbitrary type.  This method returns null if a global
+  /// arbitrary type. This method returns null if a global with the specified
-  /// with the specified name is not found.
+  /// name is not found.
   GlobalAlias *getNamedAlias(StringRef Name) const;
 
 /// @}
 /// @name Named Metadata Accessors
 /// @{
 
-  /// getNamedMetadata - Return the first NamedMDNode in the module with the
+  /// Return the first NamedMDNode in the module with the specified name. This
-  /// specified name. This method returns null if a NamedMDNode with the
+  /// method returns null if a NamedMDNode with the specified name is not found.
-  /// specified name is not found.
   NamedMDNode *getNamedMetadata(const Twine &Name) const;
 
-  /// getOrInsertNamedMetadata - Return the named MDNode in the module
+  /// Return the named MDNode in the module with the specified name. This method
-  /// with the specified name. This method returns a new NamedMDNode if a
+  /// returns a new NamedMDNode if a NamedMDNode with the specified name is not
-  /// NamedMDNode with the specified name is not found.
+  /// found.
   NamedMDNode *getOrInsertNamedMetadata(StringRef Name);
 
-  /// eraseNamedMetadata - Remove the given NamedMDNode from this module
+  /// Remove the given NamedMDNode from this module and delete it.
-  /// and delete it.
   void eraseNamedMetadata(NamedMDNode *NMD);
 
 /// @}
 /// @name Module Flags Accessors
 /// @{
 
-  /// getModuleFlagsMetadata - Returns the module flags in the provided vector.
+  /// Returns the module flags in the provided vector.
   void getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const;
 
   /// Return the corresponding value if Key appears in module flags, otherwise
   /// return null.
   Value *getModuleFlag(StringRef Key) const;
 
-  /// getModuleFlagsMetadata - Returns the NamedMDNode in the module that
+  /// Returns the NamedMDNode in the module that represents module-level flags.
-  /// represents module-level flags. This method returns null if there are no
+  /// This method returns null if there are no module-level flags.
-  /// module-level flags.
   NamedMDNode *getModuleFlagsMetadata() const;
 
-  /// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module
+  /// Returns the NamedMDNode in the module that represents module-level flags.
-  /// that represents module-level flags. If module-level flags aren't found,
+  /// If module-level flags aren't found, it creates the named metadata that
-  /// it creates the named metadata that contains them.
+  /// contains them.
   NamedMDNode *getOrInsertModuleFlagsMetadata();
 
-  /// addModuleFlag - Add a module-level flag to the module-level flags
+  /// Add a module-level flag to the module-level flags metadata. It will create
-  /// metadata. It will create the module-level flags named metadata if it
+  /// the module-level flags named metadata if it doesn't already exist.
-  /// doesn't already exist.
   void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Value *Val);
   void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, uint32_t Val);
   void addModuleFlag(MDNode *Node);
@@ -436,31 +430,31 @@ public:
 /// @name Materialization
 /// @{
 
-  /// setMaterializer - Sets the GVMaterializer to GVM.  This module must not
+  /// Sets the GVMaterializer to GVM. This module must not yet have a
-  /// yet have a Materializer.  To reset the materializer for a module that
+  /// Materializer. To reset the materializer for a module that already has one,
-  /// already has one, call MaterializeAllPermanently first.  Destroying this
+  /// call MaterializeAllPermanently first. Destroying this module will destroy
-  /// module will destroy its materializer without materializing any more
+  /// its materializer without materializing any more GlobalValues. Without
-  /// GlobalValues.  Without destroying the Module, there is no way to detach or
+  /// destroying the Module, there is no way to detach or destroy a materializer
-  /// destroy a materializer without materializing all the GVs it controls, to
+  /// without materializing all the GVs it controls, to avoid leaving orphan
-  /// avoid leaving orphan unmaterialized GVs.
+  /// unmaterialized GVs.
   void setMaterializer(GVMaterializer *GVM);
-  /// getMaterializer - Retrieves the GVMaterializer, if any, for this Module.
+  /// Retrieves the GVMaterializer, if any, for this Module.
   GVMaterializer *getMaterializer() const { return Materializer.get(); }
 
-  /// isMaterializable - True if the definition of GV has yet to be materialized
+  /// True if the definition of GV has yet to be materializedfrom the
-  /// from the GVMaterializer.
+  /// GVMaterializer.
   bool isMaterializable(const GlobalValue *GV) const;
-  /// isDematerializable - Returns true if this GV was loaded from this Module's
+  /// Returns true if this GV was loaded from this Module's GVMaterializer and
-  /// GVMaterializer and the GVMaterializer knows how to dematerialize the GV.
+  /// the GVMaterializer knows how to dematerialize the GV.
   bool isDematerializable(const GlobalValue *GV) const;
 
-  /// Materialize - Make sure the GlobalValue is fully read.  If the module is
+  /// Make sure the GlobalValue is fully read. If the module is corrupt, this
-  /// corrupt, this returns true and fills in the optional string with
+  /// returns true and fills in the optional string with information about the
-  /// information about the problem.  If successful, this returns false.
+  /// problem. If successful, this returns false.
   bool Materialize(GlobalValue *GV, std::string *ErrInfo = nullptr);
-  /// Dematerialize - If the GlobalValue is read in, and if the GVMaterializer
+  /// If the GlobalValue is read in, and if the GVMaterializer supports it,
-  /// supports it, release the memory for the function, and set it up to be
+  /// release the memory for the function, and set it up to be materialized
-  /// materialized lazily.  If !isDematerializable(), this method is a noop.
+  /// lazily. If !isDematerializable(), this method is a noop.
   void Dematerialize(GlobalValue *GV);
 
   /// Make sure all GlobalValues in this Module are fully read.