[llvm][docs] Fix typos to say subclasses need to override virtual methods but not overload

llvm/docs/WritingAnLLVMPass.rst

 ``getAnalysis`` interface ``getAnalysis<DominatorTree>(llvm::Function *)`` to
 provide the function to retrieve analysis result for, if the function pass does
 not require any module or immutable passes.  Note that this can only be done
 for functions for which the analysis ran, e.g. in the case of dominators you
 should only ask for the ``DominatorTree`` for function definitions, not
 declarations.
 
 To write a correct ``ModulePass`` subclass, derive from ``ModulePass`` and
-overload the ``runOnModule`` method with the following signature:
+override the ``runOnModule`` method with the following signature:
 
 The ``runOnModule`` method
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 .. code-block:: c++
 
   virtual bool runOnModule(Module &M) = 0;
 

 #. Inspect or modify a ``Function`` other than the one currently being processed.
 #. Add or remove ``Function``\ s from the current ``Module``.
 #. Add or remove global variables from the current ``Module``.
 #. Maintain state across invocations of :ref:`runOnFunction
    <writing-an-llvm-pass-runOnFunction>` (including global data).
 
 Implementing a ``FunctionPass`` is usually straightforward (See the :ref:`Hello
 World <writing-an-llvm-pass-basiccode>` pass for example).
-``FunctionPass``\ es may overload three virtual methods to do their work.  All
+``FunctionPass``\ es may override three virtual methods to do their work.  All
 of these methods should return ``true`` if they modified the program, or
 ``false`` if they didn't.
 
 .. _writing-an-llvm-pass-doInitialization-mod:
 
 The ``doInitialization(Module &)`` method
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

 ----------------------
 
 All ``LoopPass`` execute on each :ref:`loop <loop-terminology>` in the function
 independent of all of the other loops in the function.  ``LoopPass`` processes
 loops in loop nest order such that outer most loop is processed last.
 
 ``LoopPass`` subclasses are allowed to update loop nest using ``LPPassManager``
 interface.  Implementing a loop pass is usually straightforward.
-``LoopPass``\ es may overload three virtual methods to do their work.  All
+``LoopPass``\ es may override three virtual methods to do their work.  All
 these methods should return ``true`` if they modified the program, or ``false``
 if they didn't.
 
 A ``LoopPass`` subclass which is intended to run as part of the main loop pass
 pipeline needs to preserve all of the same *function* analyses that the other
 loop passes in its pipeline require. To make that easier,
 a ``getLoopAnalysisUsage`` function is provided by ``LoopUtils.h``. It can be
 called within the subclass's ``getAnalysisUsage`` override to get consistent

 ------------------------
 
 ``RegionPass`` is similar to :ref:`LoopPass <writing-an-llvm-pass-LoopPass>`,
 but executes on each single entry single exit region in the function.
 ``RegionPass`` processes regions in nested order such that the outer most
 region is processed last.
 
 ``RegionPass`` subclasses are allowed to update the region tree by using the
-``RGPassManager`` interface.  You may overload three virtual methods of
+``RGPassManager`` interface.  You may override three virtual methods of
 ``RegionPass`` to implement your own region pass.  All these methods should
 return ``true`` if they modified the program, or ``false`` if they did not.
 
 The ``doInitialization(Region *, RGPassManager &)`` method
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 .. code-block:: c++