[Docs][WritingAnLLVMBackend] Makefiles are deprecated

[thegameg]

Summary

• docs/WritingAnLLVMBackend.rst: Makefiles are no longer used. The users should use CMakeLists.txt. In order to add the target, the TARGETS_TO_BUILD is replaced with LLVM_ALL_TARGETS.

[beanz]

docs/WritingAnLLVMBackend.rst

163 ↗

(On Diff #58675)

You actually don't want to modify LLVM_ALL_TARGETS. Instead you want to configure with "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=Dummy". That will build the dummy target without needing to add it to "All" and we generally don't encourage adding a target to "All" until after it is stable.

[thegameg]

Prefer using LLVM_EXPERIMENTAL_TARGETS_TO_BUILD instead of adding it directly to LLVM_ALL_TARGETS.

[beanz]

LGTM

[thegameg]

Can you commit this for me @beanz? I don't have commit access. Thanks!

llvm/trunk/docs/WritingAnLLVMBackend.rst

 files.  The absolute minimum is discussed here.  But to actually use the LLVM
 target-independent code generator, you must perform the steps described in the
 :doc:`LLVM Target-Independent Code Generator <CodeGenerator>` document.
 
 First, you should create a subdirectory under ``lib/Target`` to hold all the
 files related to your target.  If your target is called "Dummy", create the
 directory ``lib/Target/Dummy``.
 
-In this new directory, create a ``Makefile``.  It is easiest to copy a
-``Makefile`` of another target and modify it.  It should at least contain the
-``LEVEL``, ``LIBRARYNAME`` and ``TARGET`` variables, and then include
-``$(LEVEL)/Makefile.common``.  The library can be named ``LLVMDummy`` (for
-example, see the MIPS target).  Alternatively, you can split the library into
-``LLVMDummyCodeGen`` and ``LLVMDummyAsmPrinter``, the latter of which should be
-implemented in a subdirectory below ``lib/Target/Dummy`` (for example, see the
-PowerPC target).
+In this new directory, create a ``CMakeLists.txt``.  It is easiest to copy a
+``CMakeLists.txt`` of another target and modify it.  It should at least contain
+the ``LLVM_TARGET_DEFINITIONS`` variable. The library can be named ``LLVMDummy``
+(for example, see the MIPS target).  Alternatively, you can split the library
+into ``LLVMDummyCodeGen`` and ``LLVMDummyAsmPrinter``, the latter of which
+should be implemented in a subdirectory below ``lib/Target/Dummy`` (for example,
+see the PowerPC target).
 
 Note that these two naming schemes are hardcoded into ``llvm-config``.  Using
 any other naming scheme will confuse ``llvm-config`` and produce a lot of
 (seemingly unrelated) linker errors when linking ``llc``.
 
 To make your target actually do something, you need to implement a subclass of
 ``TargetMachine``.  This implementation should typically be in the file
 ``lib/Target/DummyTargetMachine.cpp``, but any file in the ``lib/Target``
 directory will be built and should work.  To use LLVM's target independent code
 generator, you should do what all current machine backends do: create a
 subclass of ``LLVMTargetMachine``.  (To create a target from scratch, create a
 subclass of ``TargetMachine``.)
 
-To get LLVM to actually build and link your target, you need to add it to the
-``TARGETS_TO_BUILD`` variable.  To do this, you modify the configure script to
-know about your target when parsing the ``--enable-targets`` option.  Search
-the configure script for ``TARGETS_TO_BUILD``, add your target to the lists
-there (some creativity required), and then reconfigure.  Alternatively, you can
-change ``autoconf/configure.ac`` and regenerate configure by running
-``./autoconf/AutoRegen.sh``.
+To get LLVM to actually build and link your target, you need to run ``cmake``
+with ``-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=Dummy``. This will build your
+target without needing to add it to the list of all the targets.
+
+Once your target is stable, you can add it to the ``LLVM_ALL_TARGETS`` variable
+located in the main ``CMakeLists.txt``.
 
 Target Machine
 ==============
 
 ``LLVMTargetMachine`` is designed as a base class for targets implemented with
 the LLVM target-independent code generator.  The ``LLVMTargetMachine`` class
 should be specialized by a concrete target class that implements the various
 virtual methods.  ``LLVMTargetMachine`` is defined as a subclass of