[docs] Fix coverage doc typos and links.

[brucem]

Summary

Fix coverage doc typos and links.

[brucem]

I have commit access and don't mind committing this if given the okay.

[silvas]

docs/CoverageMappingFormat.rst

539

This just has an extra underscore and needs to be a :ref: (http://sphinx-doc.org/markup/inline.html#role-ref).

I.e. make this:

:ref:`LEB value <LEB128>`

And similarly elsewhere. No need to rewrite the label names all over the document.

[silvas]

two extra underscores, actually.

docs/CoverageMappingFormat.rst

 (Clang's ``-fprofile-instr-generate`` option).
 
 This document is aimed at those who use LLVM's code coverage mapping to provide
 code coverage analysis for their own programs, and for those who would like
 to know how it works under the hood. A prior knowledge of how Clang's profile
 guided optimization works is useful, but not required.
 
 We start by showing how to use LLVM and Clang for code coverage analysis,
-then we briefly desribe LLVM's code coverage mapping format and the
+then we briefly describe LLVM's code coverage mapping format and the
 way that Clang and LLVM's code coverage tool work with this format. After
 the basics are down, more advanced features of the coverage mapping format
 are discussed - such as the data structures, LLVM IR representation and
 the binary encoding.
 
 Quick Start
 ===========
 

 coverage mapping data that can map between the source code ranges and
 the profile instrumentation counters for that function.
 
 Mapping Region
 --------------
 
 The function's coverage mapping data contains an array of mapping regions.
 A mapping region stores the `source code range`_ that is covered by this region,
-the `file id <coverage file id_>`_, the `coverage mapping counter`_ and
+the `file id`_, the `coverage mapping counter`_ and
 the region's kind.
 There are several kinds of mapping regions:
 
 * Code regions associate portions of source code and `coverage mapping
   counters`_. They make up the majority of the mapping regions. They are used
   by the code coverage tool to compute the execution counts for lines,
   highlight the regions of code that were never executed, and to obtain
   the various code coverage statistics for a function.

 .. _source code range:
 
 Source Range:
 ^^^^^^^^^^^^^
 
 The source range record contains the starting and ending location of a certain
 mapping region. Both locations include the line and the column numbers.
 
-.. _coverage file id:
+.. _file id:
 
 File ID:
 ^^^^^^^^
 
-The file id an integer value that tells us
+The file id is an integer value that tells us
 in which source file or macro expansion is this region located.
 It enables Clang to produce mapping information for the code
 defined inside macros, like this example demonstrates:
 
 :raw-html:`<pre class='highlight' style='line-height:initial;'><span>void func(const char *str) </span><span style='background-color:#4A789C'>{        </span> <span class='c1'>// Code Region from 1:28 to 6:2 with file id 0</span>
 <span style='background-color:#4A789C'>  #define PUT </span><span style='background-color:#85C1F5'>printf("%s\n", str)</span><span style='background-color:#4A789C'>   </span> <span class='c1'>// 2 Code Regions from 2:15 to 2:34 with file ids 1 and 2</span>
 <span style='background-color:#4A789C'>  if(*str)                          </span>
 <span style='background-color:#4A789C'>    </span><span style='background-color:#F6D55D'>PUT</span><span style='background-color:#4A789C'>;                            </span> <span class='c1'>// Expansion Region from 4:5 to 4:8 with file id 0 that expands a macro with file id 1</span>
* The length of the substring that contains the encoded coverage mapping data
   +----------+-------------------------------------------------------------------------------------------------------------------------+
   | ``0x00`` | An index into the filenames array which corresponds to the file "/Users/alex/test.c".                                   |
   +----------+-------------------------------------------------------------------------------------------------------------------------+
   | ``0x00`` | The number of counter expressions used by this function. This function doesn't use any expressions.                     |
   +----------+-------------------------------------------------------------------------------------------------------------------------+
   | ``0x01`` | The number of mapping regions that are stored in an array for the function's file id #0.                                |
   +----------+-------------------------------------------------------------------------------------------------------------------------+
   | ``0x01`` | The coverage mapping counter for the first region in this function. The value of 1 tells us that it's a coverage        |
-  |          | mapping counter that is a reference ot the profile instrumentation counter with an index of 0.                          |
+  |          | mapping counter that is a reference to the profile instrumentation counter with an index of 0.                          |
   +----------+-------------------------------------------------------------------------------------------------------------------------+
   | ``0x01`` | The starting line of the first mapping region in this function.                                                         |
   +----------+-------------------------------------------------------------------------------------------------------------------------+
   | ``0x0C`` | The starting column of the first mapping region in this function.                                                       |
   +----------+-------------------------------------------------------------------------------------------------------------------------+
   | ``0x02`` | The ending line of the first mapping region in this function.                                                           |
   +----------+-------------------------------------------------------------------------------------------------------------------------+
   | ``0x02`` | The ending column of the first mapping region in this function.                                                         |
   +----------+-------------------------------------------------------------------------------------------------------------------------+
 
 * The length of the substring that contains the encoded coverage mapping data
   for the second function record is also 9. It's structured like the mapping data
   for the first function record.
 
 * The two trailing bytes are zeroes and are used to pad the coverage mapping
   data to give it the 8 byte alignment.
 
 Encoding
 ========
 
 The per-function coverage mapping data is encoded as a stream of bytes,
-with a simple structure. The structure consists of the encoding
-`types <cvmtypes_>`_ like variable-length unsigned integers, that
+with a simple structure. The structure consists of the `encoding
+types`_ like variable-length unsigned integers, that
 are used to encode `File ID Mapping`_, `Counter Expressions`_ and
 the `Mapping Regions`_.
 
 The format of the structure follows:
 
   ``[file id mapping, counter expressions, mapping regions]``
 
-The translation unit filenames are encoded using the same encoding
-`types <cvmtypes_>`_ as the per-function coverage mapping data, with the
+The translation unit filenames are encoded using the same `encoding
+types`_ as the per-function coverage mapping data, with the
 following structure:
 
   ``[numFilenames : LEB128, filename0 : string, filename1 : string, ...]``
 
-.. _cvmtypes:
+.. _encoding types:
 
 Types
 -----
 
 This section describes the basic types that are used by the encoding format
 and can appear after ``:`` in the ``[foo : type]`` description.
 
-.. _LEB128:
+.. _LEB value:
 
 LEB128
 ^^^^^^
 
-LEB128 is an unsigned interger value that is encoded using DWARF's LEB128
+LEB128 is an unsigned integer value that is encoded using DWARF's LEB128
 encoding, optimizing for the case where values are small
 (1 byte for values less than 128).
 
 .. _strings:
 
 Strings
 ^^^^^^^
 
 ``[length : LEB128, characters...]``
 
-String values are encoded with a `LEB value <LEB128_>`_ for the length
+String values are encoded with a `LEB value`_ for the length
 of the string and a sequence of bytes for its characters.
 
 .. _file id mapping:
 
 File ID Mapping
 ---------------
 
 ``[numIndices : LEB128, filenameIndex0 : LEB128, filenameIndex1 : LEB128, ...]``
 
 File id mapping in a function's coverage mapping stream
 contains the indices into the translation unit's filenames array.
 
 Counter
 -------
 
 ``[value : LEB128]``
 
-A `coverage mapping counter`_ is stored in a single `LEB value <LEB128_>`_.
-It is composed of two things --- the `tag <counter-tag_>`_
+A `coverage mapping counter`_ is stored in a single `LEB value`_.
+It is composed of two things --- the `counter tag`
 which is stored in the lowest 2 bits, and the `counter data`_ which is stored
 in the remaining bits.
 
-.. _counter-tag:
+.. _counter tag:
 
 Tag:
 ^^^^
 
 The counter's tag encodes the counter's kind
 and, if the counter is an expression, the expression's kind.
 The possible tag values are:
 

 
 Counter Expressions
 -------------------
 
 ``[numExpressions : LEB128, expr0LHS : LEB128, expr0RHS : LEB128, expr1LHS : LEB128, expr1RHS : LEB128, ...]``
 
 Counter expressions consist of two counters as they
 represent binary arithmetic operations.
-The expression's kind is determined from the `tag <counter-tag_>`_ of the
+The expression's kind is determined from the `counter tag`_ of the
 counter that references this expression.
 
 .. _Mapping Regions:
 
 Mapping Regions
 ---------------
 
 ``[numRegionArrays : LEB128, regionsForFile0, regionsForFile1, ...]``

 A mapping region whose header has a counter with a non-zero tag is
 a code region.
 
 Pseudo-Counter:
 """""""""""""""
 
 ``[value : LEB128]``
 
-A pseudo-counter is stored in a single `LEB value <LEB128_>`_, just like
+A pseudo-counter is stored in a single `LEB value`_, just like
 the ordinary counter. It has the following interpretation:
 
 * bits 0-1: tag, which is always 0.
 
 * bit 2: expansionRegionTag. If this bit is set, then this mapping region
   is an expansion region.
 
 * remaining bits: data. If this region is an expansion region, then the data