[mlir] fix broken link to Glossary

[inouehrs]

Summary

Glossary.md is missing in doc directory and links to Glossary.md are broken.
This patch copies Glossary.md from the old repository. It also touches up broken links to Glossary.md from the tutorial.

It looks like DeveloperGuide.md and TestingGuide.md have not been copied from the old repository too. Is it intentional?

[ftynse]

It's in the website repo https://github.com/llvm/mlir-www/tree/master/website/content/getting_started and visible on mlir.llvm.org. Can you only fix the broken reference?

[jpienaar]

Yes the missing docs are considered static and supposed to be in mlir-www and the links to them work on mlir.llvm.org via relative, but could be made explicit to the website here..

[inouehrs]

@ftynse @jpienaar I got it. Thank you so much for the clarification.
Instead of adding Glossary.md in the repo, broken links to Glossary.md are replaced with links to https://mlir.llvm.org/getting_started/Glossary/

[mehdi_amini]

I'd rather use relative links if you don't mind, it make it easier to work locally with a copy of the website.

[lucyrfox]

Thanks for making this fix. +1 on using relative links. While you're here, you could also make the link to the glossary in the LangRef relative.

[inouehrs]

@lucyrfox @mehdi_amini The relative links may not work if someone reads the tutorial directly on github since now Tutorial and Glossary is in the different repos. Is it acceptable?

[ftynse]

The website uses a different layout anyway so many links won't work on GitHub, we don't expect them to. We prefer to be consistent and have the website working correctly.

[inouehrs]

• make links to glossary in Tutorial and LangRef relative path.

mlir/docs/LangRef.md

 # MLIR Specification
 
 MLIR (Multi-Level IR) is a compiler intermediate representation with
 similarities to traditional three-address SSA representations (like
 [LLVM IR](http://llvm.org/docs/LangRef.html) or
 [SIL](https://github.com/apple/swift/blob/master/docs/SIL.rst)), but which
 introduces notions from polyhedral loop optimization as first-class concepts.
 This hybrid design is optimized to represent, analyze, and transform high level
 dataflow graphs as well as target-specific code generated for high performance
 data parallel systems. Beyond its representational capabilities, its single
 continuous design provides a framework to lower from dataflow graphs to
 high-performance target-specific code.
 
 This document defines and describes the key concepts in MLIR, and is intended to
 be a dry reference document - the [rationale documentation](Rationale.md),
-[glossary](https://mlir.llvm.org/getting_started/Glossary/), and other content are hosted elsewhere.
+[glossary](../getting_started/Glossary.md), and other content are hosted elsewhere.
 
 MLIR is designed to be used in three different forms: a human-readable textual
 form suitable for debugging, an in-memory form suitable for programmatic
 transformations and analysis, and a compact serialized form suitable for storage
 and transport. The different forms all describe the same semantic content. This
 document describes the human-readable textual form.
 
 [TOC]

mlir/docs/Tutorials/Toy/Ch-2.md

 `-mlir-print-debuginfo` flag specifies to include locations. (Run `mlir-opt
 --help` for more options.)
 
 ### Opaque API
 
 MLIR is designed to be a completely extensible system, and as such, the
 infrastructure has the capability to opaquely represent all of its core
 components: attributes, operations, types, etc. This allows MLIR to parse,
-represent, and [round-trip](../../Glossary.md#round-trip) any valid IR. For
+represent, and [round-trip](../../../getting_started/Glossary.md#round-trip) any valid IR. For
 example, we could place our Toy operation from above into an `.mlir` file and
 round-trip through *mlir-opt* without registering anything:
 
 ```mlir
 func @toy_func(%tensor: tensor<2x3xf64>) -> tensor<3x2xf64> {
   %t_tensor = "toy.transpose"(%tensor) { inplace = true } : (tensor<2x3xf64>) -> tensor<3x2xf64>
   return %t_tensor : tensor<3x2xf64>
 }

mlir/docs/Tutorials/Toy/Ch-5.md

 [MemRefType](../../LangRef.md#memref-type) that is indexed via an affine
 loop-nest. Tensors represent an abstract value-typed sequence of data, meaning
 that they don't live in any memory. MemRefs, on the other hand, represent lower
 level buffer access, as they are concrete references to a region of memory.
 
 # Dialect Conversions
 
 MLIR has many different dialects, so it is important to have a unified framework
-for [converting](../../Glossary.md#conversion) between them. This is where the
+for [converting](../../../getting_started/Glossary.md#conversion) between them. This is where the
 `DialectConversion` framework comes into play. This framework allows for
 transforming a set of `illegal` operations to a set of `legal` ones. To use this
 framework, we need to provide two things (and an optional third):
 
 *   A [Conversion Target](../../DialectConversion.md#conversion-target)
 
     -   This is the formal specification of what operations or dialects are
         legal for the conversion. Operations that aren't legal will require
         rewrite patterns to perform
-        [legalization](../../Glossary.md#legalization).
+        [legalization](../../../getting_started/Glossary.md#legalization).
 
 *   A set of
     [Rewrite Patterns](../../DialectConversion.md#rewrite-pattern-specification)
 
     -   These are the set of [patterns](../../QuickstartRewrites.md) used to
         convert `illegal` operations into a set of zero or more `legal` ones.
 
 *   Optionally, a [Type Converter](../../DialectConversion.md#type-conversion).

mlir/docs/Tutorials/Toy/Ch-6.md

 
 For this lowering, we will again use the dialect conversion framework to perform
 the heavy lifting. However, this time, we will be performing a full conversion
 to the [LLVM dialect](../../Dialects/LLVM.md). Thankfully, we have already
 lowered all but one of the `toy` operations, with the last being `toy.print`.
 Before going over the conversion to LLVM, let's lower the `toy.print` operation.
 We will lower this operation to a non-affine loop nest that invokes `printf` for
 each element. Note that, because the dialect conversion framework supports
-[transitive lowering](Glossary.md#transitive-lowering), we don't need to
+[transitive lowering](../../../getting_started/Glossary.md#transitive-lowering), we don't need to
 directly emit operations in the LLVM dialect. By transitive lowering, we mean
 that the conversion framework may apply multiple patterns to fully legalize an
 operation. In this example, we are generating a structured loop nest instead of
 the branch-form in the LLVM dialect. As long as we then have a lowering from the
 loop operations to LLVM, the lowering will still succeed.
 
 During lowering we can get, or build, the declaration for printf as so:
 

 
 ## Conversion Patterns
 
 Now that the conversion target has been defined, we need to provide the patterns
 used for lowering. At this point in the compilation process, we have a
 combination of `toy`, `affine`, and `std` operations. Luckily, the `std` and
 `affine` dialects already provide the set of patterns needed to transform them
 into LLVM dialect. These patterns allow for lowering the IR in multiple stages
-by relying on [transitive lowering](Glossary.md#transitive-lowering).
+by relying on [transitive lowering](../../../getting_started/Glossary.md#transitive-lowering).
 
 ```c++
   mlir::OwningRewritePatternList patterns;
   mlir::populateAffineToStdConversionPatterns(patterns, &getContext());
   mlir::populateLoopToStdConversionPatterns(patterns, &getContext());
   mlir::populateStdToLLVMConversionPatterns(typeConverter, patterns);
 
   // The only remaining operation to lower from the `toy` dialect, is the