Fix LLVM Programmer’s Manual doxygen links

[chenwj]

Summary

Some of doxygen links on LLVM Programmer’s Manual are lost or old. Fix them with the latest links.

[t.p.northover]

Looks reasonable to me.

[chenwj]

I don't have commit access, need someone's help.

[chenwj]

@t.p.northover Ping? :-)

[chenwj]

In D31578#716833, @t.p.northover wrote:

Looks reasonable to me.

@t.p.northover I have no commit access, would you like to help me commit this patch? Thanks. :-)

[dberris]

I looks like it's already committed in https://reviews.llvm.org/rL299395 as mentioned in a reply to the mailing list. Probably good to close now.

[chenwj]

@dberris Thanks for the info!

docs/ProgrammersManual.rst

 <http://llvm.org/doxygen/>`__ sources are provided to make this as easy as
 possible.
 
 The first section of this document describes general information that is useful
 to know when working in the LLVM infrastructure, and the second describes the
 Core LLVM classes.  In the future this manual will be extended with information
 describing how to use extension libraries, such as dominator information, CFG
 traversal routines, and useful utilities like the ``InstVisitor`` (`doxygen
-<http://llvm.org/doxygen/InstVisitor_8h-source.html>`__) template.
+<http://llvm.org/doxygen/InstVisitor_8h_source.html>`__) template.
 
 .. _general:
 
 General Information
 ===================
 
 This section contains general information that is useful if you are working in
 the LLVM source-base, but that isn't specific to any particular API.

 ------------------------------------------------------
 
 The LLVM source-base makes extensive use of a custom form of RTTI.  These
 templates have many similarities to the C++ ``dynamic_cast<>`` operator, but
 they don't have some drawbacks (primarily stemming from the fact that
 ``dynamic_cast<>`` only works on classes that have a v-table).  Because they are
 used so often, you must know what they do and how they work.  All of these
 templates are defined in the ``llvm/Support/Casting.h`` (`doxygen
-<http://llvm.org/doxygen/Casting_8h-source.html>`__) file (note that you very
+<http://llvm.org/doxygen/Casting_8h_source.html>`__) file (note that you very
 rarely have to include this file directly).
 
 ``isa<>``:
   The ``isa<>`` operator works exactly like the Java "``instanceof``" operator.
   It returns true or false depending on whether a reference or pointer points to
   an instance of the specified class.  This can be very useful for constraint
   checking of various sorts (example below).
 
.. code-block:: c++
 
   Map.find("foo");                 // Lookup "foo"
   Map.find(std::string("bar"));    // Lookup "bar"
   Map.find(StringRef("\0baz", 4)); // Lookup "\0baz"
 
 Similarly, APIs which need to return a string may return a ``StringRef``
 instance, which can be used directly or converted to an ``std::string`` using
 the ``str`` member function.  See ``llvm/ADT/StringRef.h`` (`doxygen
-<http://llvm.org/doxygen/classllvm_1_1StringRef_8h-source.html>`__) for more
+<http://llvm.org/doxygen/StringRef_8h_source.html>`__) for more
 information.
 
 You should rarely use the ``StringRef`` class directly, because it contains
 pointers to external memory it is not generally safe to store an instance of the
 class (unless you know that the external storage will not be freed).
 ``StringRef`` is small and pervasive enough in LLVM that it should always be
 passed by value.
 
.. code-block:: c++
     void takeCallback(Callable Callback) {
       Callback(1, 2, 3);
     }
 
 The ``function_ref`` class template
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The ``function_ref``
-(`doxygen <http://llvm.org/docs/doxygen/html/classllvm_1_1function__ref_3_01Ret_07Params_8_8_8_08_4.html>`__) class
+(`doxygen <http://llvm.org/doxygen/classllvm_1_1function__ref_3_01Ret_07Params_8_8_8_08_4.html>`__) class
 template represents a reference to a callable object, templated over the type
 of the callable. This is a good choice for passing a callback to a function,
 if you don't need to hold onto the callback after the function returns. In this
 way, ``function_ref`` is to ``std::function`` as ``StringRef`` is to
 ``std::string``.
 
 ``function_ref<Ret(Param1, Param2, ...)>`` can be implicitly constructed from
 any callable object that can be called with arguments of type ``Param1``,

 other code into your pass.  After you get it working, you want to remove it, but
 you may need it again in the future (to work out new bugs that you run across).
 
 Naturally, because of this, you don't want to delete the debug printouts, but
 you don't want them to always be noisy.  A standard compromise is to comment
 them out, allowing you to enable them if you need them in the future.
 
 The ``llvm/Support/Debug.h`` (`doxygen
-<http://llvm.org/doxygen/Debug_8h-source.html>`__) file provides a macro named
+<http://llvm.org/doxygen/Debug_8h_source.html>`__) file provides a macro named
 ``DEBUG()`` that is a much nicer solution to this problem.  Basically, you can
 put arbitrary code into the argument of the ``DEBUG`` macro, and it is only
 executed if '``opt``' (or any other tool) is run with the '``-debug``' command
 line argument:
 
 .. code-block:: c++
 
   DEBUG(errs() << "I am here!\n");
.. code-block:: c++
   DEBUG_WITH_TYPE("bar", errs() << "'bar' debug type\n"));
 
 .. _Statistic:
 
 The ``Statistic`` class & ``-stats`` option
 -------------------------------------------
 
 The ``llvm/ADT/Statistic.h`` (`doxygen
-<http://llvm.org/doxygen/Statistic_8h-source.html>`__) file provides a class
+<http://llvm.org/doxygen/Statistic_8h_source.html>`__) file provides a class
 named ``Statistic`` that is used as a unified way to keep track of what the LLVM
 compiler is doing and how effective various optimizations are.  It is useful to
 see what optimizations are contributing to making a particular program run
 faster.
 
 Often you may run your pass on some big program, and you're interested to see
 how many times it makes a certain transformation.  Although you can do this with
 hand inspection, or some ad-hoc method, this is a real pain and not very useful

 
 Replacing an Instruction with another Value
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Replacing individual instructions
 """""""""""""""""""""""""""""""""
 
 Including "`llvm/Transforms/Utils/BasicBlockUtils.h
-<http://llvm.org/doxygen/BasicBlockUtils_8h-source.html>`_" permits use of two
+<http://llvm.org/doxygen/BasicBlockUtils_8h_source.html>`_" permits use of two
 very useful replace functions: ``ReplaceInstWithValue`` and
 ``ReplaceInstWithInst``.
 
 .. _schanges_deleting_sub:
 
 Deleting Instructions
 """""""""""""""""""""
 

 
 .. code-block:: c++
 
   std::vector<const Type*> params;
   params.push_back(PointerType::getUnqual(Type::Int32Ty));
   FunctionType *ft = FunctionType::get(Type::Int8Ty, params, false);
 
 See the `class comment
-<http://llvm.org/doxygen/TypeBuilder_8h-source.html#l00001>`_ for more details.
+<http://llvm.org/doxygen/TypeBuilder_8h_source.html#l00001>`_ for more details.
 
 .. _threading:
 
 Threads and LLVM
 ================
 
 This section describes the interaction of the LLVM APIs with multithreading,
 both on the part of client applications, and in the JIT, in the hosted

 
 .. _coreclasses:
 
 The Core LLVM Class Hierarchy Reference
 =======================================
 
 ``#include "llvm/IR/Type.h"``
 
-header source: `Type.h <http://llvm.org/doxygen/Type_8h-source.html>`_
+header source: `Type.h <http://llvm.org/doxygen/Type_8h_source.html>`_
 
 doxygen info: `Type Clases <http://llvm.org/doxygen/classllvm_1_1Type.html>`_
 
 The Core LLVM classes are the primary means of representing the program being
 inspected or transformed.  The core LLVM classes are defined in header files in
 the ``include/llvm/IR`` directory, and implemented in the ``lib/IR``
 directory. It's worth noting that, for historical reasons, this library is
 called ``libLLVMCore.so``, not ``libLLVMIR.so`` as you might expect.

 
 .. _Module:
 
 The ``Module`` class
 --------------------
 
 ``#include "llvm/IR/Module.h"``
 
-header source: `Module.h <http://llvm.org/doxygen/Module_8h-source.html>`_
+header source: `Module.h <http://llvm.org/doxygen/Module_8h_source.html>`_
 
 doxygen info: `Module Class <http://llvm.org/doxygen/classllvm_1_1Module.html>`_
 
 The ``Module`` class represents the top level structure present in LLVM
 programs.  An LLVM module is effectively either a translation unit of the
 original program or a combination of several translation units merged by the
 linker.  The ``Module`` class keeps track of a list of :ref:`Function
 <c_Function>`\ s, a list of GlobalVariable_\ s, and a SymbolTable_.

 
 .. _Value:
 
 The ``Value`` class
 -------------------
 
 ``#include "llvm/IR/Value.h"``
 
-header source: `Value.h <http://llvm.org/doxygen/Value_8h-source.html>`_
+header source: `Value.h <http://llvm.org/doxygen/Value_8h_source.html>`_
 
 doxygen info: `Value Class <http://llvm.org/doxygen/classllvm_1_1Value.html>`_
 
 The ``Value`` class is the most important class in the LLVM Source base.  It
 represents a typed value that may be used (among other things) as an operand to
 an instruction.  There are many different types of ``Value``\ s, such as
 Constant_\ s, Argument_\ s.  Even Instruction_\ s and :ref:`Function
 <c_Function>`\ s are ``Value``\ s.

 
 .. _User:
 
 The ``User`` class
 ------------------
 
 ``#include "llvm/IR/User.h"``
 
-header source: `User.h <http://llvm.org/doxygen/User_8h-source.html>`_
+header source: `User.h <http://llvm.org/doxygen/User_8h_source.html>`_
 
 doxygen info: `User Class <http://llvm.org/doxygen/classllvm_1_1User.html>`_
 
 Superclass: Value_
 
 The ``User`` class is the common base class of all LLVM nodes that may refer to
 ``Value``\ s.  It exposes a list of "Operands" that are all of the ``Value``\ s
 that the User is referring to.  The ``User`` class itself is a subclass of

 .. _Instruction:
 
 The ``Instruction`` class
 -------------------------
 
 ``#include "llvm/IR/Instruction.h"``
 
 header source: `Instruction.h
-<http://llvm.org/doxygen/Instruction_8h-source.html>`_
+<http://llvm.org/doxygen/Instruction_8h_source.html>`_
 
 doxygen info: `Instruction Class
 <http://llvm.org/doxygen/classllvm_1_1Instruction.html>`_
 
 Superclasses: User_, Value_
 
 The ``Instruction`` class is the common base class for all LLVM instructions.
 It provides only a few methods, but is a very commonly used class.  The primary

 .. _GlobalValue:
 
 The ``GlobalValue`` class
 -------------------------
 
 ``#include "llvm/IR/GlobalValue.h"``
 
 header source: `GlobalValue.h
-<http://llvm.org/doxygen/GlobalValue_8h-source.html>`_
+<http://llvm.org/doxygen/GlobalValue_8h_source.html>`_
 
 doxygen info: `GlobalValue Class
 <http://llvm.org/doxygen/classllvm_1_1GlobalValue.html>`_
 
 Superclasses: Constant_, User_, Value_
 
 Global values ( GlobalVariable_\ s or :ref:`Function <c_Function>`\ s) are the
 only LLVM values that are visible in the bodies of all :ref:`Function

 
 .. _c_Function:
 
 The ``Function`` class
 ----------------------
 
 ``#include "llvm/IR/Function.h"``
 
-header source: `Function.h <http://llvm.org/doxygen/Function_8h-source.html>`_
+header source: `Function.h <http://llvm.org/doxygen/Function_8h_source.html>`_
 
 doxygen info: `Function Class
 <http://llvm.org/doxygen/classllvm_1_1Function.html>`_
 
 Superclasses: GlobalValue_, Constant_, User_, Value_
 
 The ``Function`` class represents a single procedure in LLVM.  It is actually
 one of the more complex classes in the LLVM hierarchy because it must keep track

 .. _GlobalVariable:
 
 The ``GlobalVariable`` class
 ----------------------------
 
 ``#include "llvm/IR/GlobalVariable.h"``
 
 header source: `GlobalVariable.h
-<http://llvm.org/doxygen/GlobalVariable_8h-source.html>`_
+<http://llvm.org/doxygen/GlobalVariable_8h_source.html>`_
 
 doxygen info: `GlobalVariable Class
 <http://llvm.org/doxygen/classllvm_1_1GlobalVariable.html>`_
 
 Superclasses: GlobalValue_, Constant_, User_, Value_
 
 Global variables are represented with the (surprise surprise) ``GlobalVariable``
 class.  Like functions, ``GlobalVariable``\ s are also subclasses of

 .. _BasicBlock:
 
 The ``BasicBlock`` class
 ------------------------
 
 ``#include "llvm/IR/BasicBlock.h"``
 
 header source: `BasicBlock.h
-<http://llvm.org/doxygen/BasicBlock_8h-source.html>`_
+<http://llvm.org/doxygen/BasicBlock_8h_source.html>`_
 
 doxygen info: `BasicBlock Class
 <http://llvm.org/doxygen/classllvm_1_1BasicBlock.html>`_
 
 Superclass: Value_
 
 This class represents a single entry single exit section of the code, commonly
 known as a basic block by the compiler community.  The ``BasicBlock`` class