Adjust documentation for git migration.

[jyknight]

Summary

This fixes most references to the paths:
llvm.org/svn/
llvm.org/git/
llvm.org/viewvc/
github.com/llvm-mirror/
github.com/llvm-project/
reviews.llvm.org/diffusion/

to instead point to https://github.com/llvm/llvm-project.

This is *not* a trivial substitution, because additionally, all the
checkout instructions had to be migrated to instruct users on how to
use the monorepo layout, setting LLVM_ENABLE_PROJECTS instead of
checking out various projects into various subdirectories.

I've attempted to *NOT* change any scripts here, only
documentation. The scripts will have to be addressed separately.

[jyknight]

Fix some warnings I added.

Restore TestSuiteMakefileGuide.rst, which apparently isn't 100%
obsolete. (But it is incorrect, and I'm not sure exactly how to fix
it, so I just left a FIXME).

[smeenai]

The amount of duplicated and out-of-date documentation makes me sad, but this is an awesome effort to clean that up.

lldb/packages/Python/lldbsuite/test/functionalities/command_source/TestCommandSource.py

4

Would you want to link to the corresponding GitHub commit?

lldb/packages/Python/lldbsuite/test/lang/objc/objc-optimized/TestObjcOptimized.py

4

Same here.

[mehdi_amini]

LGTM, but for one comment that requires a fix I believe (lld on Windows)

libcxx/docs/BuildingLibcxx.rst

47

So nice to see these steps going away :)

57

Wonder if it is worth mentioning somewhere how to sparse-checkout?

libcxxabi/www/index.html

86

Do you now if prefixing with CC is equivalent to -DCMAKE_C_COMPILER?

lld/docs/getting_started.rst

71

Missing -DLLVM_ENABLE_PROJECTS=lld here I believe

[labath]

I am not sure we should be recommending to people to place the build folder under the llvm-project checkout. Is that how people use the monorepo build nowadays? This is not an full out-of-source build, since the build folder is still a subfolder of the repo root (and without a .gitignore file containing the right build folder name, git will complain about untracked files in the repository)...

libcxxabi/www/index.html

86

It usually is, but it can differ once you start using cache and toolchain files. In any case, using -DCMAKE_C(XX)_COMPILER is the preferred way to do things in cmake.

[jyknight]

In D57330#1375096, @labath wrote:

I am not sure we should be recommending to people to place the build folder under the llvm-project checkout. Is that how people use the monorepo build nowadays? This is not an full out-of-source build, since the build folder is still a subfolder of the repo root (and without a .gitignore file containing the right build folder name, git will complain about untracked files in the repository)...

Well, it's certainly how I do it. I find it the least confusing, because then I don't get mixed up as to which source tree a given build directory belongs to (or directories, as I may also have build-release, build-debug, etc).

libcxx/docs/BuildingLibcxx.rst

57

Yes, I think it likely is worth mentioning that somewhere in the future -- but I'd rather not recommend it yet. There's two things that will impact that:

1. We'll need to decide where we plan to keep shared infrastructure (e.g. cmake macros etc) used by multiple subprojects within the repository.
2. It seems as though git is actually gaining new support for this kind of thing now, might be worth letting that mature a little bit.

libcxxabi/www/index.html

86

Changed to specify the cmake arguments.

lld/docs/getting_started.rst

71

Yep fixed.

lldb/packages/Python/lldbsuite/test/functionalities/command_source/TestCommandSource.py

4

After viewing said commit, I felt it wasn't actually useful to visit to understand this file, which is why I removed the link.

lldb/packages/Python/lldbsuite/test/lang/objc/objc-optimized/TestObjcOptimized.py

4

Felt the same in this case.

[mehdi_amini]

In D57330#1375096, @labath wrote:

This is not an full out-of-source build, since the build folder is still a subfolder of the repo root

My definition of what qualify an "out-of-source" build is that the build process won't touch anything outside of the build directory: i.e. the build directory itself is hermetic, self-contained, and can be destroyed without impacting anything else.
(I agree with you that polluting git status is annoying, and personally I usually have my build directories in parallel with the repo).

[smeenai]

In D57330#1375913, @mehdi_amini wrote:

In D57330#1375096, @labath wrote:

This is not an full out-of-source build, since the build folder is still a subfolder of the repo root

My definition of what qualify an "out-of-source" build is that the build process won't touch anything outside of the build directory: i.e. the build directory itself is hermetic, self-contained, and can be destroyed without impacting anything else.
(I agree with you that polluting git status is annoying, and personally I usually have my build directories in parallel with the repo).

You can avoid the git status pollution by adding the build directory to .git/info/exclude.

[mehdi_amini]

You can avoid the git status pollution by adding the build directory to .git/info/exclude.

Good to know! Should we include this in the doc?

[smeenai]

In D57330#1376069, @mehdi_amini wrote:

You can avoid the git status pollution by adding the build directory to .git/info/exclude.

Good to know! Should we include this in the doc?

I can put that change up fore review. It probably makes most sense to add it to www/get_started.html? There's lots of different places which document building, but that seems like the canonical one.

clang-tools-extra/docs/clang-rename.rst

clang-rename common options:
     -pn                        - Print the found symbol's name prior to renaming to stderr.
     -qualified-name=<string>   - The fully qualified name of the symbol.
 
 Vim Integration
 ===============
 
 You can call :program:`clang-rename` directly from Vim! To set up
 :program:`clang-rename` integration for Vim see
-`clang-rename/tool/clang-rename.py
-<https://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-rename/tool/clang-rename.py>`_.
+`clang/tools/clang-rename/clang-rename.py
+<https://github.com/llvm/llvm-project/blob/master/clang/tools/clang-rename/clang-rename.py>`_.
 
 Please note that **you have to save all buffers, in which the replacement will
 happen before running the tool**.
 
 Once installed, you can point your cursor to symbols you want to rename, press
 `<leader>cr` and type new desired name. The `<leader> key
 <http://vim.wikia.com/wiki/Mapping_keys_in_Vim_-_Tutorial_(Part_3)#Map_leader>`_
 is a reference to a specific key defined by the mapleader variable and is bound
 to backslash by default.
 
 Emacs Integration
 =================
 
 You can also use :program:`clang-rename` while using Emacs! To set up
 :program:`clang-rename` integration for Emacs see
 `clang-rename/tool/clang-rename.el
-<https://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-rename/tool/clang-rename.el>`_.
+<https://github.com/llvm/llvm-project/blob/master/clang/tools/clang-rename/clang-rename.el>`_.
 
 Once installed, you can point your cursor to symbols you want to rename, press
 `M-X`, type `clang-rename` and new desired name.
 
 Please note that **you have to save all buffers, in which the replacement will
 happen before running the tool**.

clang-tools-extra/docs/clang-tidy/Contributing.rst

 style used in the project. For code reviews we mostly use `LLVM Phabricator`_.
 
 .. _Getting Started with LLVM: https://llvm.org/docs/GettingStarted.html
 .. _LLVM Coding Standards: https://llvm.org/docs/CodingStandards.html
 .. _LLVM Phabricator: https://llvm.org/docs/Phabricator.html
 
 Next, you need to decide which module the check belongs to. Modules
 are located in subdirectories of `clang-tidy/
-<https://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-tidy/>`_
+<https://github.com/llvm/llvm-project/tree/master/clang-tools-extra/clang-tidy/>`_
 and contain checks targeting a certain aspect of code quality (performance,
 readability, etc.), certain coding style or standard (Google, LLVM, CERT, etc.)
 or a widely used API (e.g. MPI). Their names are same as user-facing check
 groups names described :ref:`above <checks-groups-table>`.
 
 After choosing the module and the name for the check, run the
 ``clang-tidy/add_new_check.py`` script to create the skeleton of the check and
 plug it to :program:`clang-tidy`. It's the recommended way of adding new checks.
if (MatchedDecl->getName().startswith("awesome_"))
       return;
     diag(MatchedDecl->getLocation(), "function %0 is insufficiently awesome")
         << MatchedDecl
         << FixItHint::CreateInsertion(MatchedDecl->getLocation(), "awesome_");
   }
 
 (If you want to see an example of a useful check, look at
 `clang-tidy/google/ExplicitConstructorCheck.h
-<https://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-tidy/google/ExplicitConstructorCheck.h>`_
+<https://github.com/llvm/llvm-project/blob/master/clang-tools-extra/clang-tidy/google/ExplicitConstructorCheck.h>`_
 and `clang-tidy/google/ExplicitConstructorCheck.cpp
 <https://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-tidy/google/ExplicitConstructorCheck.cpp>`_).
 
 
 Registering your Check
 ----------------------
 
 (The ``add_new_check.py`` takes care of registering the check in an existing

clang-tools-extra/docs/clang-tidy/Integrations.rst

 diagnostics under the `Clang Code Model`_. To employ :program:`clang-tidy`
 inspection in QtCreator, you need to create a copy of one of the presets and
 choose the checks to be performed in the Clang Code Model Warnings menu.
 
 .. _MS Visual Studio: https://visualstudio.microsoft.com/
 .. _ReSharper C++: https://www.jetbrains.com/help/resharper/Clang_Tidy_Integration.html
 .. _Visual Assist: https://docs.wholetomato.com/default.asp?W761
 .. _Clang Power Tools: https://marketplace.visualstudio.com/items?itemName=caphyon.ClangPowerTools
-.. _clang-tidy-vs: https://github.com/llvm-mirror/clang-tools-extra/tree/master/clang-tidy-vs
+.. _clang-tidy-vs: https://github.com/llvm/llvm-project/tree/master/clang-tools-extra/clang-tidy-vs
 
 `MS Visual Studio`_ has a native clang-tidy-vs_ plugin and also can integrate
 :program:`clang-tidy` by means of three other tools. The `ReSharper C++`_
 extension, version 2017.3 and later, provides seamless :program:`clang-tidy`
 integration: checks and quick-fixes run alongside native inspections. Apart
 from that, ReSharper C++ incorporates :program:`clang-tidy` as a separate
 step of its code clean-up process. `Visual Assist`_ build 2210 includes a
 subset of :program:`clang-tidy` checklist to inspect the code as you edit.

clang/.gitignore

 #==============================================================================#
 # This file specifies intentionally untracked files that git should ignore.
 # See: http://www.kernel.org/pub/software/scm/git/docs/gitignore.html
-#
-# This file is intentionally different from the output of `git svn show-ignore`,
-# as most of those are useless.
 #==============================================================================#
 
 #==============================================================================#
 # File extensions to be ignored anywhere in the tree.
 #==============================================================================#
 # Temp files created by most text editors.
 *~
 # Merge files created by git.

clang/docs/ClangPlugins.rst

.. code-block:: c++
   static PragmaHandlerRegistry::Add<ExamplePragmaHandler> Y("example_pragma","example pragma description");
 
 Putting it all together
 =======================
 
 Let's look at an example plugin that prints top-level function names.  This
 example is checked into the clang repository; please take a look at
 the `latest version of PrintFunctionNames.cpp
-<https://llvm.org/viewvc/llvm-project/cfe/trunk/examples/PrintFunctionNames/PrintFunctionNames.cpp?view=markup>`_.
+<https://github.com/llvm/llvm-project/blob/master/clang/examples/PrintFunctionNames/PrintFunctionNames.cpp>`_.
 
 Running the plugin
 ==================
 
 
 Using the cc1 command line
 --------------------------
 
.. code-block:: console
   $ clang++ -D_GNU_SOURCE -D_DEBUG -D__STDC_CONSTANT_MACROS \
             -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D_GNU_SOURCE \
             -I$BD/tools/clang/include -Itools/clang/include -I$BD/include -Iinclude \
             tools/clang/tools/clang-check/ClangCheck.cpp -fsyntax-only \
             -Xclang -load -Xclang $BD/lib/PrintFunctionNames.so -Xclang \
             -plugin -Xclang print-fns
 
 Also see the print-function-name plugin example's
-`README <https://llvm.org/viewvc/llvm-project/cfe/trunk/examples/PrintFunctionNames/README.txt?view=markup>`_
+`README <https://github.com/llvm/llvm-project/blob/master/clang/examples/PrintFunctionNames/README.txt>`_
 
 
 Using the clang command line
 ----------------------------
 
 Using `-fplugin=plugin` on the clang command line passes the plugin
 through as an argument to `-load` on the cc1 command line. If the plugin
 class implements the ``getActionType`` method then the plugin is run

clang/docs/ClangTools.rst

 ========
 Overview
 ========
 
 Clang Tools are standalone command line (and potentially GUI) tools
 designed for use by C++ developers who are already using and enjoying
 Clang as their compiler. These tools provide developer-oriented
 functionality such as fast syntax checking, automatic formatting,
 refactoring, etc.
 
 Only a couple of the most basic and fundamental tools are kept in the
-primary Clang Subversion project. The rest of the tools are kept in a
-side-project so that developers who don't want or need to build them
-don't. If you want to get access to the extra Clang Tools repository,
-simply check it out into the tools tree of your Clang checkout and
-follow the usual process for building and working with a combined
-LLVM/Clang checkout:
-
--  With Subversion:
-
-   -  ``cd llvm/tools/clang/tools``
-   -  ``svn co https://llvm.org/svn/llvm-project/clang-tools-extra/trunk extra``
-
--  Or with Git:
-
-   -  ``cd llvm/tools/clang/tools``
-   -  ``git clone https://llvm.org/git/clang-tools-extra.git extra``
+primary Clang tree. The rest of the tools are kept in a separate
+directory tree, ``clang-tools-extra
+<https://github.com/llvm/llvm-project/tree/master/clang-tools-extra>``_.
 
 This document describes a high-level overview of the organization of
 Clang Tools within the project as well as giving an introduction to some
 of the more important tools. However, it should be noted that this
 document is currently focused on Clang and Clang Tool developers, not on
 end users of these tools.
 
 Clang Tools Organization

clang/docs/ControlFlowIntegrityDesign.rst

 The compiler lays out classes of disjoint hierarchies in separate regions
 of the object file. At worst, bit vectors in disjoint hierarchies only
 need to cover their disjoint hierarchy. But the closer that classes in
 sub-hierarchies are laid out to each other, the smaller the bit vectors for
 those sub-hierarchies need to be (see "Stripping Leading/Trailing Zeros in Bit
 Vectors" above). The `GlobalLayoutBuilder`_ class is responsible for laying
 out the globals efficiently to minimize the sizes of the underlying bitsets.
 
-.. _GlobalLayoutBuilder: https://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/IPO/LowerTypeTests.h?view=markup
+.. _GlobalLayoutBuilder: https://github.com/llvm/llvm-project/blob/master/llvm/include/llvm/Transforms/IPO/LowerTypeTests.h
 
 Alignment
 ~~~~~~~~~
 
 If all gaps between address points in a particular bit vector are multiples
 of powers of 2, the compiler can compress the bit vector by strengthening
 the alignment requirements of the virtual table pointer. For example, given
 this class hierarchy:

 Split virtual table groups into separate virtual tables
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The Itanium C++ ABI glues multiple individual virtual tables for a class into a combined virtual table (virtual table group). 
 The interleaving scheme, however, can only work with individual virtual tables so it must split the combined virtual tables first.
 In comparison, the old scheme does not require the splitting but it is more efficient when the combined virtual tables have been split.
 The `GlobalSplit`_ pass is responsible for splitting combined virtual tables into individual ones. 
 
-.. _GlobalSplit: https://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/GlobalSplit.cpp?view=markup
+.. _GlobalSplit: https://github.com/llvm/llvm-project/blob/master/llvm/lib/Transforms/IPO/GlobalSplit.cpp
 
 Order virtual tables by a pre-order traversal of the class hierarchy 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 This step is common to both the old scheme described above and the interleaving scheme. 
 For the interleaving scheme, since the combined virtual tables have been split in the previous step, 
 this step ensures that for any class all the compatible virtual tables will appear consecutively. 
 For the old scheme, the same property may not hold since it may work on combined virtual tables. 

clang/docs/InternalsManual.rst

 derived from ``clang::Attr``, information for the parser to use, automated
 semantic checking for some attributes, etc.
 
 
 ``include/clang/Basic/Attr.td``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 The first step to adding a new attribute to Clang is to add its definition to
 `include/clang/Basic/Attr.td
-<https://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/Attr.td?view=markup>`_.
+<https://github.com/llvm/llvm-project/blob/master/clang/include/clang/Basic/Attr.td>`_.
 This tablegen definition must derive from the ``Attr`` (tablegen, not
 semantic) type, or one of its derivatives. Most attributes will derive from the
 ``InheritableAttr`` type, which specifies that the attribute can be inherited by
 later redeclarations of the ``Decl`` it is associated with.
 ``InheritableParamAttr`` is similar to ``InheritableAttr``, except that the
 attribute is written on a parameter instead of a declaration. If the attribute
 is intended to apply to a type instead of a declaration, such an attribute
 should derive from ``TypeAttr``, and will generally not be given an AST

 automatically. Whether the diagnostic is a warning or an error depends on how
 the attribute's ``SubjectList`` is defined, but the default behavior is to warn.
 The diagnostics displayed to the user are automatically determined based on the
 subjects in the list, but a custom diagnostic parameter can also be specified in
 the ``SubjectList``. The diagnostics generated for subject list violations are
 either ``diag::warn_attribute_wrong_decl_type`` or
 ``diag::err_attribute_wrong_decl_type``, and the parameter enumeration is found
 in `include/clang/Sema/ParsedAttr.h
-<https://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/ParsedAttr.h?view=markup>`_
+<https://github.com/llvm/llvm-project/blob/master/clang/include/clang/Sema/ParsedAttr.h>`_
 If a previously unused Decl node is added to the ``SubjectList``, the logic used
 to automatically determine the diagnostic parameter in `utils/TableGen/ClangAttrEmitter.cpp
-<https://llvm.org/viewvc/llvm-project/cfe/trunk/utils/TableGen/ClangAttrEmitter.cpp?view=markup>`_
+<https://github.com/llvm/llvm-project/blob/master/clang/utils/TableGen/ClangAttrEmitter.cpp>`_
 may need to be updated.
 
 By default, all subjects in the SubjectList must either be a Decl node defined
 in ``DeclNodes.td``, or a statement node defined in ``StmtNodes.td``. However,
 more complex subjects can be created by creating a ``SubsetSubject`` object.
 Each such object has a base subject which it appertains to (which must be a
 Decl or Stmt node, and not a SubsetSubject node), and some custom code which is
 called when determining whether an attribute appertains to the subject. For
 instance, a ``NonBitField`` SubsetSubject appertains to a ``FieldDecl``, and
 tests whether the given FieldDecl is a bit field. When a SubsetSubject is
 specified in a SubjectList, a custom diagnostic parameter must also be provided.
 
 Diagnostic checking for attribute subject lists is automated except when
 ``HasCustomParsing`` is set to ``1``.
 
 Documentation
 ~~~~~~~~~~~~~
 All attributes must have some form of documentation associated with them.
 Documentation is table generated on the public web server by a server-side
 process that runs daily. Generally, the documentation for an attribute is a
 stand-alone definition in `include/clang/Basic/AttrDocs.td 
-<https://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/AttdDocs.td?view=markup>`_
+<https://github.com/llvm/llvm-project/blob/master/clang/include/clang/Basic/AttrDocs.td>`_
 that is named after the attribute being documented.
 
 If the attribute is not for public consumption, or is an implicitly-created
 attribute that has no visible spelling, the documentation list can specify the
 ``Undocumented`` object. Otherwise, the attribute should have its documentation
 added to AttrDocs.td.
 
 Documentation derives from the ``Documentation`` tablegen type. All derived

 ``__attribute__((myattribute("Hello", 3)))`` will be a valid use; it requires
 two arguments while parsing, and the Attr subclass' constructor for the
 semantic attribute will require a string and integer argument.
 
 All arguments have a name and a flag that specifies whether the argument is
 optional. The associated C++ type of the argument is determined by the argument
 definition type. If the existing argument types are insufficient, new types can
 be created, but it requires modifying `utils/TableGen/ClangAttrEmitter.cpp
-<https://llvm.org/viewvc/llvm-project/cfe/trunk/utils/TableGen/ClangAttrEmitter.cpp?view=markup>`_
+<https://github.com/llvm/llvm-project/blob/master/clang/utils/TableGen/ClangAttrEmitter.cpp>`_
 to properly support the type.
 
 Other Properties
 ~~~~~~~~~~~~~~~~
 The ``Attr`` definition has other members which control the behavior of the
 attribute. Many of them are special-purpose and beyond the scope of this
 document, however a few deserve mention.
 
 If the parsed form of the attribute is more complex, or differs from the
 semantic form, the ``HasCustomParsing`` bit can be set to ``1`` for the class,
 and the parsing code in `Parser::ParseGNUAttributeArgs()
-<https://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseDecl.cpp?view=markup>`_
+<https://github.com/llvm/llvm-project/blob/master/clang/lib/Parse/ParseDecl.cpp>`_
 can be updated for the special case. Note that this only applies to arguments
 with a GNU spelling -- attributes with a __declspec spelling currently ignore
 this flag and are handled by ``Parser::ParseMicrosoftDeclSpec``.
 
 Note that setting this member to 1 will opt out of common attribute semantic
 handling, requiring extra implementation efforts to ensure the attribute
 appertains to the appropriate subject, etc.
 

 
 If additional functionality is desired for the semantic form of the attribute,
 the ``AdditionalMembers`` field specifies code to be copied verbatim into the
 semantic attribute class object, with ``public`` access.
 
 Boilerplate
 ^^^^^^^^^^^
 All semantic processing of declaration attributes happens in `lib/Sema/SemaDeclAttr.cpp
-<https://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaDeclAttr.cpp?view=markup>`_,
+<https://github.com/llvm/llvm-project/blob/master/clang/lib/Sema/SemaDeclAttr.cpp>`_,
 and generally starts in the ``ProcessDeclAttribute()`` function. If the
 attribute is a "simple" attribute -- meaning that it requires no custom semantic
 processing aside from what is automatically  provided, add a call to
 ``handleSimpleAttribute<YourAttr>(S, D, Attr);`` to the switch statement.
 Otherwise, write a new ``handleYourAttr()`` function, and add that to the switch
 statement. Please do not implement handling logic directly in the ``case`` for
 the attribute.
 
 Unless otherwise specified by the attribute definition, common semantic checking
 of the parsed attribute is handled automatically. This includes diagnosing
 parsed attributes that do not appertain to the given ``Decl``, ensuring the
 correct minimum number of arguments are passed, etc.
 
 If the attribute adds additional warnings, define a ``DiagGroup`` in
 `include/clang/Basic/DiagnosticGroups.td
-<https://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticGroups.td?view=markup>`_
+<https://github.com/llvm/llvm-project/blob/master/clang/include/clang/Basic/DiagnosticGroups.td>`_
 named after the attribute's ``Spelling`` with "_"s replaced by "-"s. If there
 is only a single diagnostic, it is permissible to use ``InGroup<DiagGroup<"your-attribute">>``
 directly in `DiagnosticSemaKinds.td
-<https://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td?view=markup>`_
+<https://github.com/llvm/llvm-project/blob/master/clang/include/clang/Basic/DiagnosticSemaKinds.td>`_
 
 All semantic diagnostics generated for your attribute, including automatically-
 generated ones (such as subjects and argument counts), should have a
 corresponding test case.
 
 Semantic handling
 ^^^^^^^^^^^^^^^^^
 Most attributes are implemented to have some effect on the compiler. For

clang/docs/LibASTMatchersTutorial.rst

 abstract syntax tree (AST). To this end, the reader is incouraged to
 skim the :doc:`Introduction to the Clang
 AST <IntroductionToTheClangAST>`
 
 Step 0: Obtaining Clang
 =======================
 
 As Clang is part of the LLVM project, you'll need to download LLVM's
-source code first. Both Clang and LLVM are maintained as Subversion
-repositories, but we'll be accessing them through the git mirror. For
-further information, see the `getting started
-guide <https://llvm.org/docs/GettingStarted.html>`_.
+source code first. Both Clang and LLVM are in the same git repository,
+under different directories. For further information, see the `getting
+started guide <https://llvm.org/docs/GettingStarted.html>`_.
 
 .. code-block:: console
 
-      mkdir ~/clang-llvm && cd ~/clang-llvm
-      git clone https://llvm.org/git/llvm.git
-      cd llvm/tools
-      git clone https://llvm.org/git/clang.git
-      cd clang/tools
-      git clone https://llvm.org/git/clang-tools-extra.git extra
-
-Next you need to obtain the CMake build system and Ninja build tool. You
-may already have CMake installed, but current binary versions of CMake
-aren't built with Ninja support.
+      cd ~/clang-llvm
+      git clone https://github.com/llvm/llvm-project.git
+
+Next you need to obtain the CMake build system and Ninja build tool.
 
 .. code-block:: console
 
       cd ~/clang-llvm
       git clone https://github.com/martine/ninja.git
       cd ninja
       git checkout release
       ./bootstrap.py
       sudo cp ninja /usr/bin/
 
       cd ~/clang-llvm
       git clone git://cmake.org/stage/cmake.git
       cd cmake
       git checkout next
       ./bootstrap
       make
       sudo make install
 
 Okay. Now we'll build Clang!
 
 .. code-block:: console
 
       cd ~/clang-llvm
       mkdir build && cd build
-      cmake -G Ninja ../llvm -DLLVM_BUILD_TESTS=ON  # Enable tests; default is off.
+      cmake -G Ninja ../llvm -DLLVM_ENABLE_PROJECTS=clang -DLLVM_BUILD_TESTS=ON  # Enable tests; default is off.
       ninja
       ninja check       # Test LLVM only.
       ninja clang-test  # Test Clang only.
       ninja install
 
 And we're live.
 
-All of the tests should pass, though there is a (very) small chance that
-you can catch LLVM and Clang out of sync. Running ``'git svn rebase'``
-in both the llvm and clang directories should fix any problems.
+All of the tests should pass.
 
 Finally, we want to set Clang as its own compiler.
 
 .. code-block:: console
 
       cd ~/clang-llvm/build
       ccmake ../llvm
 

clang/docs/LibTooling.rst

 the binary directory of a clang install next to the clang binary.
 
 Tips: if your tool fails to find ``stddef.h`` or similar headers, call the tool
 with ``-v`` and look at the search paths it looks through.
 
 Linking
 ^^^^^^^
 
-For a list of libraries to link, look at one of the tools' Makefiles (for
-example `clang-check/Makefile
-<https://llvm.org/viewvc/llvm-project/cfe/trunk/tools/clang-check/Makefile?view=markup>`_).
+For a list of libraries to link, look at one of the tools' CMake files (for
+example `clang-check/CMakeList.txt
+<https://github.com/llvm/llvm-project/blob/master/clang/tools/clang-check/CMakeLists.txt>`_).

clang/docs/Toolchain.rst

 the language-neutral stack unwinding portion of the Itanium C++ ABI
 (`Level I <https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html#base-abi>`_).
 It is a dependency of the C++ ABI library, and sometimes is a dependency
 of other runtimes.
 
 libunwind (LLVM)
 ^^^^^^^^^^^^^^^^
 
-LLVM's unwinder library can be obtained from subversion:
-
-.. code-block:: console
-
-  llvm-src$ svn co https://llvm.org/svn/llvm-project/libunwind/trunk projects/libunwind
-
-When checked out into projects/libunwind within an LLVM checkout,
-it should be automatically picked up by the LLVM build system.
+LLVM's unwinder library is part of the llvm-project git repository. To
+build it, pass ``-DLLVM_ENABLE_PROJECTS=libunwind`` to the cmake invocation.
 
 If using libc++abi, you may need to configure it to use libunwind
 rather than libgcc_s by passing ``-DLIBCXXABI_USE_LLVM_UNWINDER=YES``
 to ``cmake``. If libc++abi is configured to use some version of
 libunwind, that library will be implicitly linked into binaries that
 link to libc++abi.
 
 libgcc_s (GNU)

clang/lib/CodeGen/CGOpenMPRuntime.cpp

~InlinedOpenMPRegionRAII() {
     std::swap(CGF.LambdaCaptureFields, LambdaCaptureFields);
     CGF.LambdaThisCaptureField = LambdaThisCaptureField;
     CGF.BlockInfo = BlockInfo;
   }
 };
 
 /// Values for bit flags used in the ident_t to describe the fields.
 /// All enumeric elements are named and described in accordance with the code
-/// from http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h
+/// from https://github.com/llvm/llvm-project/blob/master/openmp/runtime/src/kmp.h
 enum OpenMPLocationFlags : unsigned {
   /// Use trampoline for internal microtask.
   OMP_IDENT_IMD = 0x01,
   /// Use c-style ident structure.
   OMP_IDENT_KMPC = 0x02,
   /// Atomic reduction option for kmpc_reduce.
   OMP_ATOMIC_REDUCE = 0x10,
   /// Explicit 'barrier' directive.
enum OpenMPLocationFlags : unsigned {
   OMP_IDENT_WORK_SECTIONS = 0x400,
   /// Call of __kmp_for_static_init for distribute.
   OMP_IDENT_WORK_DISTRIBUTE = 0x800,
   LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/OMP_IDENT_WORK_DISTRIBUTE)
 };
 
 /// Describes ident structure that describes a source location.
 /// All descriptions are taken from
-/// http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h
+/// https://github.com/llvm/llvm-project/blob/master/openmp/runtime/src/kmp.h
 /// Original structure:
 /// typedef struct ident {
 ///    kmp_int32 reserved_1;   /**<  might be used in Fortran;
 ///                                  see above  */
 ///    kmp_int32 flags;        /**<  also f.flags; KMP_IDENT_xxx flags;
 ///                                  KMP_IDENT_KMPC identifies this union
 ///                                  member  */
 ///    kmp_int32 reserved_2;   /**<  not really used in Fortran any more;
Address CGOpenMPRuntime::getOrCreateDefaultLocation(unsigned Flags) {
   unsigned Reserved2Flags = getDefaultLocationReserved2Flags();
   FlagsTy FlagsKey(Flags, Reserved2Flags);
   llvm::Value *Entry = OpenMPDefaultLocMap.lookup(FlagsKey);
   if (!Entry) {
     if (!DefaultOpenMPPSource) {
       // Initialize default location for psource field of ident_t structure of
       // all ident_t objects. Format is ";file;function;line;column;;".
       // Taken from
-      // http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp_str.c
+      // https://github.com/llvm/llvm-project/blob/master/openmp/runtime/src/kmp_str.cpp
       DefaultOpenMPPSource =
           CGM.GetAddrOfConstantCString(";unknown;unknown;0;0;;").getPointer();
       DefaultOpenMPPSource =
           llvm::ConstantExpr::getBitCast(DefaultOpenMPPSource, CGM.Int8PtrTy);
     }
 
     llvm::Constant *Data[] = {
         llvm::ConstantInt::getNullValue(CGM.Int32Ty),
llvm::Value *TaskEntry = emitProxyTaskFunction(
       CGM, Loc, D.getDirectiveKind(), KmpInt32Ty, KmpTaskTWithPrivatesPtrQTy,
       KmpTaskTWithPrivatesQTy, KmpTaskTQTy, SharedsPtrTy, TaskFunction,
       TaskPrivatesMap);
 
   // Build call kmp_task_t * __kmpc_omp_task_alloc(ident_t *, kmp_int32 gtid,
   // kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
   // kmp_routine_entry_t *task_entry);
   // Task flags. Format is taken from
-  // http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h,
+  // https://github.com/llvm/llvm-project/blob/master/openmp/runtime/src/kmp.h,
   // description of kmp_tasking_flags struct.
   enum {
     TiedFlag = 0x1,
     FinalFlag = 0x2,
     DestructorsFlag = 0x8,
     PriorityFlag = 0x20
   };
   unsigned Flags = Data.Tied ? TiedFlag : 0;

 }
 
 Address
 CGOpenMPSIMDRuntime::getParameterAddress(CodeGenFunction &CGF,
                                          const VarDecl *NativeParam,
                                          const VarDecl *TargetParam) const {
   llvm_unreachable("Not supported in SIMD-only mode");
 }
-

clang/www/analyzer/checker_dev_manual.html

 
 Here are some additional resources that are useful when working on the Clang
 Static Analyzer:
 
 <ul>
 <li><a href="http://lcs.ios.ac.cn/~xuzb/canalyze/memmodel.pdf">Xu, Zhongxing &
 Kremenek, Ted & Zhang, Jian. (2010). A Memory Model for Static Analysis of C
 Programs.</a></li>
-<li><a href="https://github.com/llvm-mirror/clang/blob/master/lib/StaticAnalyzer/README.txt">
+<li><a href="https://github.com/llvm/llvm-project/blob/master/clang/lib/StaticAnalyzer/README.txt">
 The Clang Static Analyzer README</a></li>
-<li><a href="https://github.com/llvm-mirror/clang/blob/master/docs/analyzer/RegionStore.txt">
+<li><a href="https://github.com/llvm/llvm-project/blob/master/clang/docs/analyzer/RegionStore.txt">
 Documentation for how the Store works</a></li>
-<li><a href="https://github.com/llvm-mirror/clang/blob/master/docs/analyzer/IPA.txt">
+<li><a href="https://github.com/llvm/llvm-project/blob/master/clang/docs/analyzer/IPA.txt">
 Documentation about inlining</a></li>
 <li> The "Building a Checker in 24 hours" presentation given at the <a
 href="http://llvm.org/devmtg/2012-11">November 2012 LLVM Developer's
 meeting</a>. Describes the construction of SimpleStreamChecker. <a
 href="http://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">Slides</a>
 and <a
 href="https://youtu.be/kdxlsP5QVPw">video</a>
 are available.</li>

clang/www/get_started.html

 
 <p>Clang is released as part of regular LLVM releases. You can download the release versions from <a href="https://llvm.org/releases/">https://llvm.org/releases/</a>.</p>
 <p>Clang is also provided in all major BSD or GNU/Linux distributions as part of their respective packaging systems. From Xcode 4.2, Clang is the default compiler for Mac OS X.</p>
 
 <h2 id="build">Building Clang and Working with the Code</h2>
 
 <h3 id="buildNix">On Unix-like Systems</h3>
 
-<p>Note: as an experimental setup, you can use a <b>single checkout</b> with all the projects, and an <b>easy CMake invocation</b>, see the LLVM Doc "<a href="https://llvm.org/docs/GettingStarted.html#for-developers-to-work-with-a-git-monorepo">For developers to work with a git monorepo</a>"</p>
-
 <p>If you would like to check out and build Clang, the current procedure is as
 follows:</p>
 
 <ol>
   <li>Get the required tools.
   <ul>
     <li>See
       <a href="https://llvm.org/docs/GettingStarted.html#requirements">
       Getting Started with the LLVM System - Requirements</a>.</li>
     <li>Note also that Python is needed for running the test suite.
       Get it at: <a href="http://www.python.org/download">
       http://www.python.org/download</a></li>
     <li>Standard build process uses CMake. Get it at:
       <a href="http://www.cmake.org/download">
       http://www.cmake.org/download</a></li>
   </ul>
 
-  <li>Check out LLVM:
+  <li>Check out the LLVM project:
   <ul>
     <li>Change directory to where you want the llvm directory placed.</li>
-    <li><tt>svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm</tt></li>
-  </ul>
-  </li>
-  <li>Check out Clang:
-  <ul>
-    <li><tt>cd llvm/tools</tt></li>
-    <li><tt>svn co http://llvm.org/svn/llvm-project/cfe/trunk clang</tt></li>
-    <li><tt>cd ../..</tt></li>
-  </ul>
-  </li>
-  <li>Check out extra Clang tools: (optional)
-  <ul>
-    <li><tt>cd llvm/tools/clang/tools</tt></li>
-    <li><tt>svn co http://llvm.org/svn/llvm-project/clang-tools-extra/trunk
-        extra</tt></li>
-    <li><tt>cd ../../../..</tt></li>
-  </ul>
-  </li>
-  <li>Check out Compiler-RT (optional):
-  <ul>
-    <li><tt>cd llvm/projects</tt></li>
-    <li><tt>svn co http://llvm.org/svn/llvm-project/compiler-rt/trunk
-        compiler-rt</tt></li>
-    <li><tt>cd ../..</tt></li>
-  </ul>
-  </li>
-  <li>Check out libcxx: (only required to build and run Compiler-RT tests on OS X, optional otherwise)
-  <ul>
-    <li><tt>cd llvm/projects</tt></li>
-    <li><tt>svn co http://llvm.org/svn/llvm-project/libcxx/trunk
-        libcxx</tt></li>
-    <li><tt>cd ../..</tt></li>
+    <li><tt>git clone https://github.com/llvm/llvm-project.git</tt></li>
   </ul>
   </li>
   <li>Build LLVM and Clang:
   <ul>
+    <li><tt>cd llvm-project</tt></li>
     <li><tt>mkdir build</tt> (in-tree build is not supported)</li>
     <li><tt>cd build</tt></li>
-    <li><tt>cmake -G "Unix Makefiles" ../llvm</tt></li>
+    <li><tt>cmake -DLLVM_ENABLE_PROJECTS=clang -G "Unix Makefiles" ../llvm</tt></li>
     <li><tt>make</tt></li>
     <li>This builds both LLVM and Clang for debug mode.</li>
     <li>Note: For subsequent Clang development, you can just run
         <tt>make clang</tt>.</li>
     <li>CMake allows you to generate project files for several IDEs: Xcode,
         Eclipse CDT4, CodeBlocks, Qt-Creator (use the CodeBlocks generator),
         KDevelop3. For more details see
         <a href="https://llvm.org/docs/CMake.html">Building LLVM with CMake</a>
<ol>
   </li>
   <li>Run the testsuite:
   <ul>
     <li><tt>make check-clang</tt></li>
   </ul>
   </li>
 </ol>
 
-<h3>Simultaneously Building Clang and LLVM:</h3>
-
-<p>Once you have checked out Clang into the llvm source tree it will build along
-with the rest of <tt>llvm</tt>. To build all of LLVM and Clang together all at
-once simply run <tt>make</tt> from the root LLVM directory.</p>
-
-<p>If you encounter problems while building Clang, make sure that your LLVM
-checkout is at the same revision as your Clang checkout. LLVM's interfaces
-change over time, and mismatched revisions are not expected to work
-together. We recommend writing a script to automatically run <tt>svn up</tt> in
-each repository to keep them synchronized. Alternatively, you may consider using
-the unofficial
-<a href="https://llvm.org/docs/GettingStarted.html#for-developers-to-work-with-a-git-monorepo">git monorepo</a>
-which automatically keeps everything in sync at the same revision and lets you
-commit changes atomically across multiple LLVM subprojects.</p>
-
 <h3 id="buildWindows">Using Visual Studio</h3>
 
 <p>The following details setting up for and building Clang on Windows using
 Visual Studio:</p>
 
 <ol>
   <li>Get the required tools:
   <ul>
-    <li><b>Subversion</b>.  Source code control program.  Get it from:
-        <a href="https://subversion.apache.org/packages.html">
-        https://subversion.apache.org/packages.html</a></li>
+    <li><b>Git</b>.  Source code control program.  Get it from:
+        <a href="https://git-scm.com/download">
+        https://git-scm.com/download</a></li>
     <li><b>CMake</b>.  This is used for generating Visual Studio solution and
         project files.  Get it from:
         <a href="https://cmake.org/download/">
         https://cmake.org/download/</a></li>
     <li><b>Visual Studio 2015 or later</b></li>
     <li><b>Python</b>.  It is used to run the clang test suite. Get it from:
         <a href="https://www.python.org/download/">
         https://www.python.org/download/</a></li>
     <li><b>GnuWin32 tools</b>
         The Clang and LLVM test suite use various GNU core utilities, such as
         <tt>grep</tt>, <tt>sed</tt>, and <tt>find</tt>. The gnuwin32 packages
         are the oldest and most well-tested way to get these tools. However, the
         MSys utilities provided by git for Windows have been known to work.
         Cygwin has worked in the past, but is not well tested.
         If you don't already have the core utilies from some other source, get
         gnuwin32 from <a href="http://getgnuwin32.sourceforge.net/">
         http://getgnuwin32.sourceforge.net/</a>.</li>
   </ul>
   </li>
 
-  <li>Check out LLVM:
+  <li>Check out LLVM and Clang:
   <ul>
-    <li><tt>svn co https://llvm.org/svn/llvm-project/llvm/trunk llvm</tt></li>
-  </ul>
-  </li>
-  <li>Check out Clang:
-  <ul>
-     <li><tt>cd llvm\tools</tt>
-     <li><tt>svn co https://llvm.org/svn/llvm-project/cfe/trunk clang</tt></li>
+    <li><tt>git clone https://github.com/llvm/llvm-project.git</tt></li>
   </ul>
-  <p><em>Note</em>:  Some Clang tests are sensitive to the line endings.  Ensure
-     that checking out the files does not convert LF line endings to CR+LF.
-     If you use git-svn, make sure your <tt>core.autocrlf</tt> setting is false.</p>
+  <p><em>Note</em>: Some Clang tests are sensitive to the line endings.  Ensure
+     that checking out the files does not convert LF line endings to CR+LF.  If
+     you're using git on Windows, make sure your <tt>core.autocrlf</tt> setting
+     is false.</p>
   </li>
   <li>Run CMake to generate the Visual Studio solution and project files:
   <ul>
     <li><tt>cd ..\..</tt>  (back to where you started)</li>
     <li><tt>mkdir build</tt> (for building without polluting the source dir)</li>
     <li><tt>cd build</tt></li>
     <li>
       If you are using Visual Studio 2017:
-      <tt>cmake -G "Visual Studio 15 2017" -A x64 -Thost=x64 ..\llvm</tt><br/>
+      <tt>cmake -DLLVM_ENABLE_PROJECTS=clang -G "Visual Studio 15 2017" -A x64 -Thost=x64 ..\llvm</tt><br/>
       <tt>-Thost=x64</tt> is required, since the 32-bit linker will run out of memory.
     </li>
     <li>To generate x86 binaries instead of x64, pass <tt>-A Win32</tt>.</li>
     <li>See the <a href="https://www.llvm.org/docs/CMake.html">LLVM CMake guide</a> for
         more information on other configuration options for CMake.</li>
     <li>The above, if successful, will have created an LLVM.sln file in the
        <tt>build</tt> directory.
   </ul>
   </li>
   <li>Build Clang:
   <ul>
     <li>Open LLVM.sln in Visual Studio.</li>
     <li>Build the "clang" project for just the compiler driver and front end, or
       the "ALL_BUILD" project to build everything, including tools.</li>
   </ul>
   </li>
   <li>Try it out (assuming you added llvm/debug/bin to your path).  (See the
     running examples from above.)</li>
   <li>See <a href="hacking.html#testingWindows">
      Hacking on clang - Testing using Visual Studio on Windows</a> for information
      on running regression tests on Windows.</li>
 </ol>
 
-<p>Note that once you have checked out both llvm and clang, to synchronize
-to the latest code base, use the <tt>svn update</tt> command in both the
-llvm and llvm\tools\clang directories, as they are separate repositories.</p>
-
 <h3 id="buildWindowsNinja">Using Ninja alongside Visual Studio</h3>
 
 <p>We recommend that developers who want the fastest incremental builds use the
 <a href="https://ninja-build.org/">Ninja build system</a>. You can use the
 generated Visual Studio project files to edit Clang source code and generate a
 second build directory next to it for running the tests with these steps:</p>
 
 <ol>

clang/www/hacking.html

<ul>
       <li>The <a href="docs/InternalsManual.html#QualType"><tt>QualType</tt></a>
       structure is used pervasively. This is a simple value class for
       wrapping types with qualifiers; you can use
       the <tt>isConstQualified()</tt>, for example, to get one of the
       qualifiers, and the <tt>getTypePtr()</tt> method to get the
       wrapped <tt>Type*</tt> which you can then dump.</li>
       <li>For <a href="http://lldb.llvm.org"> <tt>LLDB</tt></a> users there are
       data formatters for clang data structures in
-      <a href="http://llvm.org/svn/llvm-project/cfe/trunk/utils/ClangDataFormat.py">
-      <tt>utils/ClangDataFormat.py</tt></a>.</li>
+      <a href="https://github.com/llvm/llvm-project/blob/master/clang/utils/ClangDataFormat.py">
+      <tt>clang/utils/ClangDataFormat.py</tt></a>.</li>
     </ul>
 
   <!--=====================================================================-->
   <h3 id="debuggingVisualStudio">Debugging using Visual Studio</h3>
   <!--=====================================================================-->
 
   <p>The files 
-    <a href="http://llvm.org/svn/llvm-project/llvm/trunk/utils/LLVMVisualizers/llvm.natvis">
-      <tt>utils/LLVMVisualizers/llvm.natvis</tt></a> and 
-    <a href="http://llvm.org/svn/llvm-project/cfe/trunk/utils/ClangVisualizers/clang.natvis">
-      <tt>utils/ClangVisualizers/clang.natvis</tt></a> provide debugger visualizers 
+    <a href="https://github.com/llvm/llvm-project/blob/master/llvm/utils/LLVMVisualizers/llvm.natvis">
+      <tt>llvm/utils/LLVMVisualizers/llvm.natvis</tt></a> and 
+    <a href="https://github.com/llvm/llvm-project/blob/master/clang/utils/ClangVisualizers/clang.natvis">
+      <tt>clang/utils/ClangVisualizers/clang.natvis</tt></a> provide debugger visualizers 
       that make debugging of more complex data types much easier.</p>
   <p>For Visual Studio 2013 only, put the files into 
     <tt>%USERPROFILE%\Documents\Visual Studio 2013\Visualizers</tt> or 
     create a symbolic link so they update automatically.</p>
   <p>For later versions of Visual Studio, no installation is required.
     Note also that later versions of Visual Studio also display better visualizations.</p>
 
   <!--=====================================================================-->

clang/www/menu.html.incl

<div class="submenu">
     <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits List</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
     <a href="http://planet.clang.org/">Planet Clang</a>
     <a href="irc://irc.oftc.net/llvm">IRC: irc.oftc.net#llvm</a>
   </div>
 
   <div class="submenu">
     <label>The Code</label>
-    <a href="/get_started.html#build">Check Out SVN</a>
-    <a href="http://llvm.org/svn/llvm-project/cfe/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/">Browse ViewVC</a>
+    <a href="/get_started.html#build">Check Out Sources</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/clang/">Browse Sources</a>
     <a href="http://clang.llvm.org/doxygen/">doxygen</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="http://llvm.org/reports/coverage/">Testing Coverage</a>
   </div>
 
   <div class="submenu">
     <label>Clang Events</label>
     <a href="http://llvm.org/devmtg/">LLVM Meeting</a>
   </div>
 
 </div>

compiler-rt/include/sanitizer/tsan_interface_atomic.h

#if defined(__SIZEOF_INT128__) \
     || (__clang_major__ * 100 + __clang_minor__ >= 302)
 __extension__ typedef __int128 __tsan_atomic128;
 # define __TSAN_HAS_INT128 1
 #else
 # define __TSAN_HAS_INT128 0
 #endif
 
 // Part of ABI, do not change.
-// http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/atomic?view=markup
+// https://github.com/llvm/llvm-project/blob/master/libcxx/include/atomic
 typedef enum {
   __tsan_memory_order_relaxed,
   __tsan_memory_order_consume,
   __tsan_memory_order_acquire,
   __tsan_memory_order_release,
   __tsan_memory_order_acq_rel,
   __tsan_memory_order_seq_cst
 } __tsan_memory_order;

compiler-rt/lib/tsan/rtl/tsan_interface.h

#if !SANITIZER_GO && (defined(__SIZEOF_INT128__) \
     || (__clang_major__ * 100 + __clang_minor__ >= 302)) && !defined(__mips64)
 __extension__ typedef __int128 a128;
 # define __TSAN_HAS_INT128 1
 #else
 # define __TSAN_HAS_INT128 0
 #endif
 
 // Part of ABI, do not change.
-// http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/atomic?view=markup
+// https://github.com/llvm/llvm-project/blob/master/libcxx/include/atomic
 typedef enum {
   mo_relaxed,
   mo_consume,
   mo_acquire,
   mo_release,
   mo_acq_rel,
   mo_seq_cst
 } morder;

compiler-rt/www/index.html

<li> lib/builtins/(arch) has optimized versions of some routines
          for the supported architectures.</li>
     <li> test/ contains test suites for compiler-rt runtimes.</li>
    </ul>
     
   <!--=====================================================================-->
   <h2>Get it and get involved!</h2>
   <!--=====================================================================-->
   
-  <p>Generally, you need to build LLVM/Clang in order to build compiler-rt. You can
-  either follow the Clang's
-  <a href="http://clang.llvm.org/get_started.html">Getting Started</a> page, or
+  <p>Generally, you need to build LLVM/Clang in order to build compiler-rt. You
+    can build it either together with llvm and clang, or separately.
+
+  <p>To build it together, simply add compiler-rt to the -DLLVM_ENABLE_PROJECTS= option to
+    cmake.
+
+  <p>To build it separately, first
   <a href="http://llvm.org/docs/CMake.html#quick-start">build LLVM</a>
   separately to get llvm-config binary, and then run:
 
   <ul>
-  <li>svn co http://llvm.org/svn/llvm-project/compiler-rt/trunk compiler-rt</li>
-  <li>mkdir build</li>
-  <li>cd build</li>
+  <li>cd llvm-project</li>
+  <li>mkdir build-compiler-rt</li>
+  <li>cd build-compiler-rt</li>
   <li>cmake ../compiler-rt -DLLVM_CONFIG_PATH=/path/to/llvm-config</li>
   <li>make</li>
   </ul>
 
   <p>Tests for sanitizer runtimes are ported to
   <a href="http://llvm.org/docs/CommandGuide/lit.html">llvm-lit</a> and are
   run by <b>make check-all</b> command in LLVM/Clang/compiler-rt build tree.</p>
 

compiler-rt/www/menu.html.incl

 <div id="menu">
   <div>
     <a href="http://llvm.org/">LLVM Home</a>
   </div>
   
   <div class="submenu">
     <label>compiler-rt Info</label>
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="http://lists.llvm.org/mailman/listinfo/llvm-dev">llvm-dev</a>
     <a href="http://lists.llvm.org/mailman/listinfo/llvm-commits">llvm-commits</a>
     <a href="http://llvm.org/bugs/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/compiler-rt/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/compiler-rt/">Browse Sources</a>
   </div>
 </div>

libclc/www/index.html

 
 <p>
 libclc currently supports the AMDGCN, and R600 and NVPTX targets, but
 support for more targets is welcome.
 </p>
 
 <h2>Download</h2>
 
-<tt>svn checkout http://llvm.org/svn/llvm-project/libclc/trunk libclc</tt> (<a href="http://llvm.org/viewvc/llvm-project/libclc/trunk/">ViewVC</a>)
-<br>- or -<br>
-<tt>git clone http://llvm.org/git/libclc.git</tt>
+<tt>git clone https://github.com/llvm/llvm-project.git</tt> (<a href="https://github.com/llvm/llvm-project/tree/libclc">View sources</a>)
 
 <h2>Mailing List</h2>
 
 [e-mail] (<a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/libclc-dev">subscribe/unsubscribe</a>, <a href="http://lists.llvm.org/pipermail/libclc-dev/">archives</a>)
 
 </body>
 </html>

libcxx/docs/BuildingLibcxx.rst

 ===============
 
 On Mac OS 10.7 (Lion) and later, the easiest way to get this library is to install
 Xcode 4.2 or later.  However if you want to install tip-of-trunk from here
 (getting the bleeding edge), read on.
 
 The basic steps needed to build libc++ are:
 
-#. Checkout LLVM:
-
-   * ``cd where-you-want-llvm-to-live``
-   * ``svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm``
-
-#. Checkout libc++:
-
-   * ``cd where-you-want-llvm-to-live``
-   * ``cd llvm/projects``
-   * ``svn co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx``
-
-#. Checkout libc++abi:
-
-   * ``cd where-you-want-llvm-to-live``
-   * ``cd llvm/projects``
-   * ``svn co http://llvm.org/svn/llvm-project/libcxxabi/trunk libcxxabi``
-
-#. Configure and build libc++ with libc++abi:
-
-   CMake is the only supported configuration system.
-
-   Clang is the preferred compiler when building and using libc++.
-
-   * ``cd where you want to build llvm``
-   * ``mkdir build``
-   * ``cd build``
-   * ``cmake -G <generator> [options] <path to llvm sources>``
+#. Checkout and configure LLVM (including libc++ and libc++abi), according to the `LLVM
+   getting started <https://llvm.org/docs/GettingStarted.html>`_ documentation. Make sure
+   to include ``libcxx`` and ``libcxxabi`` in the ``LLVM_ENABLE_PROJECTS`` option passed
+   to CMake.
 
    For more information about configuring libc++ see :ref:`CMake Options`.
 
    * ``make cxx`` --- will build libc++ and libc++abi.
    * ``make check-cxx check-cxxabi`` --- will run the test suites.
 
    Shared libraries for libc++ and libc++ abi should now be present in llvm/build/lib.
    See :ref:`using an alternate libc++ installation <alternate libcxx>`
.. warning::
      * Replacing your systems libc++ installation could render the system non-functional.
      * Mac OS X will not boot without a valid copy of ``libc++.1.dylib`` in ``/usr/lib``.
 
 
 The instructions are for building libc++ on
 FreeBSD, Linux, or Mac using `libc++abi`_ as the C++ ABI library.
 On Linux, it is also possible to use :ref:`libsupc++ <libsupcxx>` or libcxxrt.
 
-It is sometimes beneficial to build outside of the LLVM tree. An out-of-tree
-build would look like this:
+It is sometimes beneficial to build separately from the full LLVM build. An
+out-of-tree build would look like this:
 
 .. code-block:: bash
 
   $ cd where-you-want-libcxx-to-live
-  $ # Check out llvm, libc++ and libc++abi.
-  $ ``svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm``
-  $ ``svn co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx``
-  $ ``svn co http://llvm.org/svn/llvm-project/libcxxabi/trunk libcxxabi``
+  $ # Check out the sources (includes everything, but we'll only use libcxx)
+  $ ``git clone https://github.com/llvm/llvm-project.git``
   $ cd where-you-want-to-build
   $ mkdir build && cd build
   $ export CC=clang CXX=clang++
-  $ cmake -DLLVM_PATH=path/to/llvm \
+  $ cmake -DLLVM_PATH=path/to/separate/llvm \
           -DLIBCXX_CXX_ABI=libcxxabi \
-          -DLIBCXX_CXX_ABI_INCLUDE_PATHS=path/to/libcxxabi/include \
-          path/to/libcxx
+          -DLIBCXX_CXX_ABI_INCLUDE_PATHS=path/to/separate/libcxxabi/include \
+          path/to/llvm-project/libcxx
   $ make
   $ make check-libcxx # optional
 
 
 Experimental Support for Windows
 --------------------------------
 
 The Windows support requires building with clang-cl as cl does not support one

libcxx/docs/index.rst

 
 Quick Links
 ===========
 * `LLVM Homepage <http://llvm.org/>`_
 * `libc++abi Homepage <http://libcxxabi.llvm.org/>`_
 * `LLVM Bugzilla <https://bugs.llvm.org/>`_
 * `libcxx-commits Mailing List`_
 * `libcxx-dev Mailing List`_
-* `Browse libc++ -- SVN <http://llvm.org/svn/llvm-project/libcxx/trunk/>`_
-* `Browse libc++ -- ViewVC <http://llvm.org/viewvc/llvm-project/libcxx/trunk/>`_
+* `Browse libc++ Sources <https://github.com/llvm/llvm-project/tree/master/libcxx/>`_

libcxx/www/TS_deprecation.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
 <p>The "end game" of a Technical Specification (TS) is to have the features in there added to a future version of the C++ standard. When this happens, the TS can be retired. Sometimes, only part of at TS is added to the standard, and the rest of the features may be incorporated into the next version of the TS.</p>
 
 <p>Adoption leaves library implementors with two implementations of a feature, one in namespace <tt>std</tt>, and the other in namespace <tt>std::experimental</tt>. The first one will continue to evolve (via issues and papers), while the other will not. Gradually they will diverge. It's not good for users to have two (subtly) different implementations of the same functionality in the same library.</p>
 

libcxx/www/atomic_design.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>&lt;atomic&gt; design</h1>
   <!--*********************************************************************-->
 

libcxx/www/atomic_design_a.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>&lt;atomic&gt; design</h1>
   <!--*********************************************************************-->
 

libcxx/www/atomic_design_b.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>&lt;atomic&gt; design</h1>
   <!--*********************************************************************-->
 

libcxx/www/atomic_design_c.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>&lt;atomic&gt; design</h1>
   <!--*********************************************************************-->
 

libcxx/www/cxx1y_status.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>libc++ C++14 Status</h1>
   <!--*********************************************************************-->
 

libcxx/www/cxx1z_status.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>libc++ C++17 Status</h1>
   <!--*********************************************************************-->
 

libcxx/www/cxx2a_status.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>libc++ C++2a Status</h1>
   <!--*********************************************************************-->
 

libcxx/www/index.html

<div id="menu">
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://libcxxabi.llvm.org/">libc++abi</a>
     <a href="https://lists.llvm.org/mailman/listinfo/libcxx-dev">libcxx-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/libcxx-commits">libcxx-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>"libc++" C++ Standard Library</h1>
   <!--*********************************************************************-->
 

libcxx/www/ts1z_status.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>Post-C++14 TS Implementation Status</h1>
   <!--*********************************************************************-->
 

libcxx/www/type_traits_design.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>Type traits intrinsic design</h1>
   <!--*********************************************************************-->
 

libcxx/www/upcoming_meeting.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>libc++ Upcoming Meeting Status</h1>
   <!--*********************************************************************-->
 

libcxxabi/www/index.html

<div id="menu">
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="https://libcxx.llvm.org/">libc++</a>
     <a href="http://lists.llvm.org/mailman/listinfo/libcxx-dev">libcxx-dev</a>
     <a href="http://lists.llvm.org/mailman/listinfo/libcxx-commits">libcxx-commits</a>
     <a href="http://llvm.org/bugs/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxxabi/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxxabi/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxxabi/">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>"libc++abi" C++ Standard Library Support</h1>
   <!--*********************************************************************-->
 
<div id="content">
 
    <p>libc++abi is complete.  <a href="spec.html">Here</a> is a
    list of functionality.</p>
 
   <!--=====================================================================-->
   <h2>Get it and get involved!</h2>
   <!--=====================================================================-->
 
-  <p>To check out the code, use:</p>
+  <p>To check out the code (including llvm and others), use:</p>
 
   <ul>
-  <li><code>svn co http://llvm.org/svn/llvm-project/libcxxabi/trunk libcxxabi</code></li>
+  <li><code>git clone https://github.com/llvm/llvm-project.git</code></li>
   </ul>
 
   <p>To build:</p>
   <ul>
-  <li>Check out libcxxabi into <code>llvm/projects</code></li>
-  <li><code>cd llvm</code></li>
+  <li><code>cd llvm-project</code></li>
   <li><code>mkdir build &amp;&amp; cd build</code></li>
-  <li><code>cmake .. # on linux you may need to prefix with CC=clang CXX=clang++</code></li>
+  <li><code>cmake -DLLVM_ENABLE_PROJECTS=libcxxabi ../llvm # on linux you may need to prefix with CC=clang CXX=clang++</code></li>
   <li><code>make</code></li>
   </ul>
 
   <p>To do a standalone build:</p>
   <ul>
   <li>
-    Check out the <a href="http://libcxx.llvm.org">libcxx source</a> tree.
+    Check out the source tree. This includes the other subprojects, but you'll only use the libcxxabi part.
   </li>
-  <li><code>cd libcxxabi</code></li>
-  <li><code>mkdir build &amp;&amp; cd build</code></li>
-  <li><code>cmake -DLIBCXXABI_LIBCXX_PATH=path/to/libcxx .. # on
+  <li><code>cd llvm-project</code></li>
+  <li><code>mkdir build-libcxxabi &amp;&amp; cd build-libcxxabi</code></li>
+  <li><code>cmake -DLIBCXXABI_LIBCXX_PATH=path/to/libcxx ../libcxxabi # on
     linux you may need -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++</code></li>
   <li><code>make</code></li>
   </ul>
   <p> By default CMake uses <code>llvm-config</code> to locate the required
       LLVM sources. If CMake cannot find <code>llvm-config</code> then you must
       configure CMake using either of the following options.
   </p>
   <ul>

libunwind/docs/BuildingLibunwind.rst

 ===============
 
 On Mac OS, the easiest way to get this library is to link with -lSystem.
 However if you want to build tip-of-trunk from here (getting the bleeding
 edge), read on.
 
 The basic steps needed to build libc++ are:
 
-#. Checkout LLVM:
+#. Checkout LLVM, libunwind, and related projects:
 
    * ``cd where-you-want-llvm-to-live``
-   * ``svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm``
-
-#. Checkout libunwind:
-
-   * ``cd where-you-want-llvm-to-live``
-   * ``cd llvm/runtimes``
-   * ``svn co http://llvm.org/svn/llvm-project/libunwind/trunk libunwind``
+   * ``git clone https://github.com/llvm/llvm-project.git``
 
 #. Configure and build libunwind:
 
    CMake is the only supported configuration system.
 
    Clang is the preferred compiler when building and using libunwind.
 
    * ``cd where you want to build llvm``
    * ``mkdir build``
    * ``cd build``
-   * ``cmake -G <generator> [options] <path to llvm sources>``
+   * ``cmake -G <generator> -DLLVM_ENABLE_PROJECTS=libunwind [options] <path to llvm sources>``
 
    For more information about configuring libunwind see :ref:`CMake Options`.
 
    * ``make unwind`` --- will build libunwind.
    * ``make check-unwind`` --- will run the test suite.
 
    Shared and static libraries for libunwind should now be present in llvm/build/lib.
 

libunwind/docs/index.rst

 
 
 Quick Links
 ===========
 * `LLVM Homepage <http://llvm.org/>`_
 * `LLVM Bugzilla <https://bugs.llvm.org/>`_
 * `cfe-commits Mailing List`_
 * `cfe-dev Mailing List`_
-* `Browse libunwind -- SVN <http://llvm.org/svn/llvm-project/libunwind/trunk/>`_
-* `Browse libunwind -- ViewVC <http://llvm.org/viewvc/llvm-project/libunwind/trunk/>`_
+* `Browse libunwind Sources <https://github.com/llvm/llvm-project/blob/master/libunwind/>`_

lld/docs/getting_started.rst

* `Clang 3.1`_\+ or GCC 4.7+ (C++11 support is required).
     * If using Clang, you will also need `libc++`_.
   * `Python 2.4`_\+ (not 3.x) for running tests.
 
 .. _CMake 2.8: http://www.cmake.org/cmake/resources/software.html
 .. _Clang 3.1: http://clang.llvm.org/
 .. _libc++: http://libcxx.llvm.org/
 .. _Python 2.4: http://python.org/download/
 
-2. Check out LLVM::
+2. Check out LLVM and subprojects (including lld)::
 
-     $ cd path/to/llvm-project
-     $ svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm
-
-3. Check out lld::
-
-     $ cd llvm/tools
-     $ svn co http://llvm.org/svn/llvm-project/lld/trunk lld
-
-  * lld can also be checked out to ``path/to/llvm-project`` and built as an external
-    project.
+     $ git clone https://github.com/llvm/llvm-project.git
 
 4. Build LLVM and lld::
 
-     $ cd path/to/llvm-build/llvm (out of source build required)
-     $ cmake -G "Unix Makefiles" path/to/llvm-project/llvm
+     $ cd llvm-project
+     $ mkdir build && cd build
+     $ cmake -G "Unix Makefiles" -DLLVM_ENABLE_PROJECTS=lld ../llvm
      $ make
 
   * If you want to build with clang and it is not the default compiler or
     it is installed in an alternate location, you'll need to tell the cmake tool
     the location of the C and C++ compiler via CMAKE_C_COMPILER and
     CMAKE_CXX_COMPILER. For example::
 
         $ cmake -DCMAKE_CXX_COMPILER=/path/to/clang++ -DCMAKE_C_COMPILER=/path/to/clang ...
#. Get the required tools.
   * `CMake 2.8`_\+.
   * `Visual Studio 12 (2013) or later`_ (required for C++11 support)
   * `Python 2.4`_\+ (not 3.x) for running tests.
 
 .. _CMake 2.8: http://www.cmake.org/cmake/resources/software.html
 .. _Visual Studio 12 (2013) or later: http://www.microsoft.com/visualstudio/11/en-us
 .. _Python 2.4: http://python.org/download/
 
-#. Check out LLVM::
-
-     $ cd path/to/llvm-project
-     $ svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm
-
-#. Check out lld::
-
-     $ cd llvm/tools
-     $ svn co http://llvm.org/svn/llvm-project/lld/trunk lld
-
-  * lld can also be checked out to ``path/to/llvm-project`` and built as an external
-    project.
+#. Check out LLVM as above.
 
 #. Generate Visual Studio project files::
 
-     $ cd path/to/llvm-build/llvm (out of source build required)
-     $ cmake -G "Visual Studio 11" path/to/llvm-project/llvm
+     $ cd llvm-project/build (out of source build required)
+     $ cmake -G "Visual Studio 11" ../llvm
 
 #. Build
 
   * Open LLVM.sln in Visual Studio.
   * Build the ``ALL_BUILD`` target.
 
 #. Test
 
   * Build the ``lld-test`` target.
 
 More Information
 ~~~~~~~~~~~~~~~~
 
 For more information on using CMake see the `LLVM CMake guide`_.
 
 .. _LLVM CMake guide: http://llvm.org/docs/CMake.html

lld/docs/index.rst

 <http://llvm.org/docs/GettingStarted.html>`_.
 
 If you haven't checked out LLVM, the easiest way to build LLD is to
 check out the entire LLVM projects/sub-projects from a git mirror and
 build that tree. You need `cmake` and of course a C++ compiler.
 
 .. code-block:: console
 
-  $ git clone https://github.com/llvm-project/llvm-project-20170507 llvm-project
+  $ git clone https://github.com/llvm/llvm-project llvm-project
   $ mkdir build
   $ cd build
   $ cmake -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_PROJECTS=lld -DCMAKE_INSTALL_PREFIX=/usr/local ../llvm-project/llvm
   $ make install
 
 Using LLD
 ---------
 

lldb/docs/building-with-debug-llvm.txt

-This document describes how to build a debug version of LLVM for use with
-LLDB, and how to make LLDB use it.  
-
-It assumes that you are using the Xcode 3 series (I used 3.2.4) to build 
-LLDB.  It also assumes that your shell is /bin/bash, and that you are
-currently at a shell prompt in a checked-out LLDB repository.
-
-1.  Check out LLVM and Clang from their repositories.  To determine
-  the revision to use, consult scripts/build-llvm.pl (this is done
-  in the first command line below).  !!! WARNING Do not use the
-  name "llvm" for your checkout, for reasons described in part 3
-  below.
-
-  $ export CLANG_REVISION=`cat scripts/build-llvm.pl | grep ^our.*llvm_revision | cut -d \' -f 2,2`
-  $ svn co -r $CLANG_REVISION http://llvm.org/svn/llvm-project/llvm/trunk llvm.checkout
-  $ svn co -r $CLANG_REVISION http://llvm.org/svn/llvm-project/cfe/trunk llvm.checkout/tools/clang
-
-2.  Configure LLVM/Clang with the proper options and compilers.  I use:
-
-  $ cd llvm.checkout
-  $ CC="cc -g -O0" CXX="c++ -g -O0" ./configure --disable-optimized --enable-assertions --enable-targets=x86_64,arm
-  $ CC="cc -g -O0" CXX="c++ -g -O0" make -j 2
-  $ cd ..
-
-3.  Create a link to the built LLVM.  !!! WARNING: Do not rename the
-  directory!  The LLVM builder script that runs as part of the Xcode
-  build keys off the fact that llvm/ is a symlink to recognize that
-  we are building with a custom debug build.
-
-  $ ln -sf llvm.checkout llvm
-
-4.  Make sure that your Xcode project is set up correctly.  Open
-  lldb.xcodeproj and do the following:
-
-  Under "Targets" in the Groups & Files navigator, double-click
-  lldb-tool.  In the resulting window, select "Debug" from the
-  "Configuration:" drop-down.  Then, make sure that the setting
-  "Build Active Architecture Only" is enabled.  Close the window.
-
-  Under "Targets" in the Groups & Files navigator, double-click
-  LLDB.  In the resulting window, select "Debug" from the
-  "Configuration:" drop-down.  Then, make sure that the setting
-  "Build Active Architecture Only" is enabled.  Close the window.
-
-5.  Ensure that Xcode is building the lldb-tool target in Debug 
-  configuration for your architecture (typically x86_64).  You
-  can usually pick these options from the Overview drop-down at
-  the top left of the Xcode window.
-
-6.  Build lldb.xcodeproj.
-

lldb/packages/Python/lldbsuite/test/functionalities/command_source/TestCommandSource.py

 """
 Test that lldb command "command source" works correctly.
-
-See also http://llvm.org/viewvc/llvm-project?view=rev&revision=109673.
 """
 
 from __future__ import print_function
 
 
 import os
 import sys
 import lldb

lldb/packages/Python/lldbsuite/test/lang/objc/objc-optimized/TestObjcOptimized.py

 """
 Test that objective-c expression parser continues to work for optimized build.
 
-http://llvm.org/viewvc/llvm-project?rev=126973&view=rev
 Fixed a bug in the expression parser where the 'this'
 or 'self' variable was not properly read if the compiler
 optimized it into a register.
 """
 
 from __future__ import print_function
 
 

lldb/utils/vim-lldb/doc/lldb.txt

 On Mac OS X (under MacVim) , the following key mappings are available:
 
 <Command-B>             Insert a breakpoint at the line under cursor
 
 
 ABOUT                                           *lldb-about*
 
 Grab the latest version of this plugin (and LLDB sources) with:
-  git clone http://llvm.org/git/lldb
+  git clone https://github.com/llvm/llvm-project.git
 
 File any bugs at:
   http://llvm.org/bugs/enter_bug.cgi?product=lldb
 
  vim:tw=78:et:ft=help:norl:

lldb/www/adding-language-support.html

<div id="content">
           <div class="postfooter"></div>
         </div>
         -->
       <div class="post">
         <h1 class="postheader">Add the Language to the LanguageType enum</h1>
         <div class="postcontent">
             <p>
               The LanguageType enum
-              (see <a href="http://llvm.org/svn/llvm-project/lldb/trunk/include/lldb/lldb-enumerations.h">lldb-enumerations.h</a>)
+              (see <a href="https://github.com/llvm/llvm-project/blob/master/lldb/include/lldb/lldb-enumerations.h">lldb-enumerations.h</a>)
               contains a list of every language known to LLDB. It is
               the one place where support for a language must live
               that will need to merge cleanly with core LLDB if you
               are developing your language support in a separate
               branch. When adding support for a language previously
               unknown to LLDB, start by adding an enumeration entry to
               LanguageType.
             </p>
           </div>
           <div class="postfooter"></div>
         </div>
       <div class="post">
         <h1 class="postheader">Add a TypeSystem for the Language</h1>
         <div class="postcontent">
             <p>
-              Both <a href="http://llvm.org/svn/llvm-project/lldb/trunk/include/lldb/Core/Module.h">Module</a>
-              and <a href="http://llvm.org/svn/llvm-project/lldb/trunk/include/lldb/Target/Target.h">Target</a>
+              Both <a href="https://github.com/llvm/llvm-project/blob/master/lldb/include/lldb/Core/Module.h">Module</a>
+              and <a href="https://github.com/llvm/llvm-project/blob/master/lldb/include/lldb/Target/Target.h">Target</a>
               support the retrieval of a TypeSystem instance via
               GetTypeSystemForLanguage(). For Module, this method is
               directly on the Module instance. For Target, this is
               retrieved indirectly via the TypeSystemMap for the
               Target instance.
             </p>
             <p>
               The TypeSystem instance returned by the Target is
<div id="content">
         </div>
         <div class="post">
         <h1 class="postheader">Add Expression Evaluation Support</h1>
         <div class="postcontent">
             <p>
               Expression Evaluation support is enabled by implementing
               the relevant methods on a TypeSystem-derived class.
               Search for "Expression" in the
-              <a href="http://llvm.org/svn/llvm-project/lldb/trunk/include/lldb/Symbol/TypeSystem.h">TypeSystem header</a>
+              <a href="https://github.com/llvm/llvm-project/blob/master/lldb/include/lldb/Symbol/TypeSystem.h">TypeSystem header</a>
               to find relevant
               methods to implement.
             </p>
           </div>
           <div class="postfooter"></div>
         </div>
       <div class="post">
         <h1 class="postheader">Type Completion</h1>
<div id="content">
         </div>
       <div class="post">
         <h1 class="postheader">Creating Types</h1>
         <div class="postcontent">
             <p>
               Your TypeSystem will need an approach for creating types
               based on a set of Modules.  If your type info is going
               to come from DWARF info, you will want to subclass
-              <a href="http://llvm.org/svn/llvm-project/lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h">DWARFASTParser</a>.
+              <a href="https://github.com/llvm/llvm-project/blob/master/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h">DWARFASTParser</a>.
             </p>
           </div>
           <div class="postfooter"></div>
         </div>
       
       <div class="post">
         <h1 class="postheader">Language and LanguageRuntime plugins</h1>
         <div class="postcontent">

lldb/www/build.html

<div id="content">
             </ul>
             <p>To install the prerequisites for building the documentation (on Debian/Ubuntu) do:</p>
             <code>
               <br />&gt; sudo apt-get install doxygen graphviz
               <br />&gt; sudo pip install epydoc # or install package python-epydoc
             </code>
             <h2>Building LLDB</h2>
             <p>
-              We first need to checkout the source trees into the appropriate locations.  Both
-              Clang and LLDB build as subprojects of LLVM.  This means we will be checking out
-              the source for both Clang and LLDB into the <tt>tools</tt> subdirectory of LLVM.  We
-              will be setting up a directory hierarchy looking something like this:
-            </p>
-            <p>
-              <pre><tt>  
-                  llvm
-                  |
-                  `-- tools
-                      |
-                      +-- clang
-                      |
-                      `-- lldb
-                </tt></pre>
-            </p>
-            <p>
-              For reference, we will call the root of the LLVM project tree <tt>$llvm</tt>, and the
-              roots of the Clang and LLDB source trees <tt>$clang</tt> and <tt>$lldb</tt> respectively.
-            </p>
-            <p>Change to the directory where you want to do development work and checkout LLVM:</p>
-            <code>&gt; svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm</code>
-
-            <p>Now switch to LLVM&#8217;s tools subdirectory and checkout both Clang and LLDB:</p>
-            <code>
-              &gt; cd $llvm/tools
-              <br />&gt; svn co http://llvm.org/svn/llvm-project/cfe/trunk clang
-              <br />&gt; svn co http://llvm.org/svn/llvm-project/lldb/trunk lldb
-            </code>
-
-            <p>
-              In general, building the LLDB trunk revision requires trunk revisions of both
-              LLVM and Clang.
-            </p>
-            <p>
-              It is highly recommended that you build the system out of tree.  Create a second
-              build directory and configure the LLVM project tree to your specifications as
-              outlined in LLVM&#8217;s <em>Getting Started Guide</em>.  A typical build procedure
-              might be:
-            </p>
-            <code>
-              &gt; cd $llvm/..
+              LLDB requires both LLVM and Clang to build. We first need to checkout the source tree,
+              which contains all three. Change to the directory where you want to do development
+              work and clone the repository:</p>
+            <code>&gt; git clone https://github.com/llvm/llvm-project.git
+              <br />&gt; cd llvm-project
               <br />&gt; mkdir build
               <br />&gt; cd build
             </code>
             <h2>To build with CMake</h2>
             <p>
               Using CMake is documented on the <a href="http://llvm.org/docs/CMake.html">Building LLVM with CMake</a>
               page. Building LLDB is possible using one of the following generators:
             </p>
             <ul>
               <li> Ninja </li>
               <li> Unix Makefiles </li>
             </ul>
             <h3>Using CMake + Ninja</h3>
             <p>
               Ninja is the fastest way to build LLDB! In order to use ninja, you need to have recent versions of CMake and
               ninja on your system. To build using ninja:
             </p>
             <code>
-              &gt; cmake ../llvm -G Ninja
+              &gt; cmake ../llvm -G Ninja -DLLVM_ENABLE_PROJECTS='clang;lldb'
               <br />&gt; ninja lldb
               <br />&gt; ninja check-lldb
             </code>
             <p>
               If you want to debug the lldb that you're building -- that is, build it with debug info enabled -- pass
               two additional arguments to cmake before running ninja:
             </p>
             <code>
-              &gt; cmake ../llvm -G Ninja -DLLDB_EXPORT_ALL_SYMBOLS=1 -DCMAKE_BUILD_TYPE=Debug
+              &gt; cmake ../llvm -G Ninja -DLLVM_ENABLE_PROJECTS='clang;lldb' -DLLDB_EXPORT_ALL_SYMBOLS=1 -DCMAKE_BUILD_TYPE=Debug
             </code>
             <h3>Using CMake + Unix Makefiles</h3>
             <p>If you do not have Ninja, you can still use CMake to generate Unix Makefiles that build LLDB:</p>
             <code>
               &gt; cmake ..
               <br />&gt; make
               <br />&gt; make check-lldb
             </code>

lldb/www/index.html

<div id="middle">
 
       <div class="post">
         <h1 class ="postheader">Get it and get involved!</h1>
         <div class="postcontent">
 
             <p>To check out the code, use:</p>
 
             <ul>
-                <li>svn co http://llvm.org/svn/llvm-project/lldb/trunk lldb</li>
+                <li>git clone https://github.com/llvm/llvm-project.git</li>
             </ul>
 
             <p>Note that LLDB generally builds from top-of-trunk</p>
             <ul>
                 <li>On Mac OS X with Xcode</li>
                 <li>On Linux and FreeBSD (with clang and libstdc++/libc++)</li>
                 <li>On NetBSD (with GCC and clang and libstdc++/libc++)</li>
                 <li>On Windows with VS 2012 or higher using CMake</li>

lldb/www/python-reference.html

<div class="post">
       <div class="postcontent">
 
                 <p>A slightly esoteric use of the Python API's is to construct custom stepping types.  LLDB's stepping is
                    driven by a stack of "thread plans" and a fairly simple state machine that runs the plans.  You can create
                    a Python class that works as a thread plan, and responds to the requests the state machine makes to run
                    its operations. </p>
                 <p>There is a longer discussion of scripted thread plans and the state machine, and several interesting examples
                    of their use in:</p>
-        <a href="http://llvm.org/svn/llvm-project/lldb/trunk/examples/python/scripted_step.py">scripted_step.py</a>
+        <a href="https://github.com/llvm/llvm-project/blob/master/lldb/examples/python/scripted_step.py">scripted_step.py</a>
 
                 <p> And for a MUCH fuller discussion of the whole state machine, see:</p>
 
-        <a href="http://llvm.org/svn/llvm-project/lldb/trunk/include/lldb/Target/ThreadPlan.h">ThreadPlan.h</a>
+        <a href="https://github.com/llvm/llvm-project/blob/master/lldb/include/lldb/Target/ThreadPlan.h">ThreadPlan.h</a>
              
                 <p>If you are reading those comments it is useful to know that scripted thread plans are set to be
                   "MasterPlans", and not "OkayToDiscard".
 
                 <p>To implement a scripted step, you define a python class that has the following methods:</p>
 </tt></pre></code>
                     <p><table class="stats" width="620" cellspacing="0">
                     <tr>

 The "ls" python command has been installed and is ready for use.
 (lldb) <strong>ls -l /tmp/</strong>
 total 365848
 -rw-r--r--@  1 someuser  wheel         6148 Jan 19 17:27 .DS_Store
 -rw-------   1 someuser  wheel         7331 Jan 19 15:37 crash.log
 </tt></pre></code>
         <p>A more interesting template has been created in the source repository that can help you to create
             lldb command quickly:</p>
-        <a href="http://llvm.org/svn/llvm-project/lldb/trunk/examples/python/cmdtemplate.py">cmdtemplate.py</a>
+        <a href="https://github.com/llvm/llvm-project/blob/master/lldb/examples/python/cmdtemplate.py">cmdtemplate.py</a>
     <p>
     A commonly required facility is being able to create a command that does some token substitution, and then runs a different debugger command
     (usually, it po'es the result of an expression evaluated on its argument). For instance, given the following program:
     <code><pre><tt>
 #import &lt;Foundation/Foundation.h&gt;
 NSString*
 ModifyString(NSString* src)
 {

lldb/www/scripting.html

</h1>
                    current frame to find the variable named "dictionary" and return it.  We then 
                    store the returned value in the Python variable named "root".  This answers the 
                    question of HOW to get the variable, but it still doesn't explain WHAT actually
                    gets put into "root".  If you examine the LLDB API, you will find that the 
                    SBFrame method "FindVariable" returns an object of type SBValue. SBValue 
                    objects are used, among other things, to wrap up program variables and values.
                    There are many useful methods defined in the SBValue class to allow you to get 
                    information or children values out of SBValues.  For complete information, see 
-                   the header file <a href="http://llvm.org/svn/llvm-project/lldb/trunk/include/lldb/API/SBValue.h">SBValue.h</a>.  The 
+                   the header file <a href="https://github.com/llvm/llvm-project/blob/master/lldb/include/lldb/API/SBValue.h">SBValue.h</a>.  The 
                    SBValue methods that we use in our DFS function are 
                    <code>GetChildMemberWithName()</code>, 
                    <code>GetSummary()</code>, and <code>GetValue()</code>.</p>
 
         </div>
         <div class="postfooter"></div>
 
 
</tt></pre></code>
 
                 </div>
                 <div class="postfooter"></div>
 
                   <p> The complete code for the Dictionary program (with case-conversion bug), 
                   the DFS function and other Python script examples (tree_utils.py) used for this 
                   example are available via following file links:</p>
 
-<a href="http://llvm.org/svn/llvm-project/lldb/trunk/examples/scripting/tree_utils.py">tree_utils.py</a>  -  Example Python functions using LLDB's API, including DFS<br>
-<a href="http://llvm.org/svn/llvm-project/lldb/trunk/examples/scripting/dictionary.c">dictionary.c</a>  -  Sample dictionary program, with bug<br>
+<a href="https://github.com/llvm/llvm-project/blob/master/lldb/examples/scripting/tree_utils.py">tree_utils.py</a>  -  Example Python functions using LLDB's API, including DFS<br>
+<a href="https://github.com/llvm/llvm-project/blob/master/lldb/examples/scripting/dictionary.c">dictionary.c</a>  -  Sample dictionary program, with bug<br>
           
                     <p>The text for "Romeo and Juliet" can be obtained from the Gutenberg Project
                     (http://www.gutenberg.org).</p>
             </div>
         </div>
   </div>
 </div>
 </body>
 </html>

lldb/www/sidebar.incl

<ul>
       <li><a href="/download.html">Download</a></li>
       <li><a href="/python_reference/index.html">Python API Documentation</a></li>
       <li><a href="/cpp_reference/html/index.html">C++ API Documentation</a></li>
       <li><a href="/source.html">Source</a></li>
       <li><a href="/build.html">Build</a></li>
       <li><a href="/test.html">Test</a></li>
       <li><a href="/SB-api-coding-rules.html">SB API Coding Rules</a></li>
       <li><a href="http://bugs.llvm.org">Bug Reports</a></li>
-      <li><a href="http://llvm.org/svn/llvm-project/lldb/trunk">Browse SVN</a></li>
-      <li><a href="http://llvm.org/viewvc/llvm-project/lldb/trunk">Browse ViewVC</a></li>
+      <li><a href="https://github.com/llvm/llvm-project/tree/master/lldb/">Browse Sources</a></li>
     </ul>
     </div>
   </div>
 </div>

lldb/www/source.html

<div id="container">
   <!--#include virtual="sidebar.incl"-->
 
     <div id="middle">
       <div class="post">
         <h1 class ="postheader">Checking out LLDB sources</h1>
         <div class="postcontent">
           <p>Refer to the <a href="http://llvm.org/docs/GettingStarted.html#getting-started-with-llvm">LLVM Getting Started Guide</a>
              for general instructions on how to check out source.  Note that LLDB depends on having a working checkout of LLVM
-             and Clang, so the first step is to download LLVM and Clang sources as described at the above URL.  Then you can
-             additionally download the LLDB sources from the following repository URLs.</p>
-          <p><b>SVN Repository</b>: http://llvm.org/svn/llvm-project/lldb/trunk </p>
-          <p><b>Git Clone</b>: http://llvm.org/git/lldb.git </p>
-          <p>
-            For non-Mac platforms, and for MacOSX building with CMake (not Xcode), you should check out your sources to adhere to
-            the following directory structure:
-            <pre><tt>  
-                  llvm
-                  |
-                  `-- tools
-                      |
-                      +-- clang
-                      |
-                      `-- lldb
-                </tt></pre>
-          </p>
+             and Clang, so the first step is to download and build as described at the above URL. The same repository also
+             contains LLDB.</p>
+          <p><b>Git browser</b>: https://github.com/llvm/llvm-project/tree/master/lldb </p>
           <p>
             For MacOSX building from Xcode, simply checkout LLDB and then build from Xcode.  The Xcode project will
             automatically detect that it is a fresh checkout, and checkout LLVM and clang automatically.  Unlike other
             platforms / build systems, it will use the following directory structure.
             <pre><tt>  
                   lldb
                   |
                   `-- llvm

lldb/www/symbolication.html

--source-frames=NFRAMES
                         show source for NFRAMES (default = 4)
   --source-all          show source for all threads, not just the crashed
                         thread
   -i, --interactive     parse all crash logs and enter interactive mode
 
 </tt></pre></code>
             <p>The source for the "symbolication" and "crashlog" modules are available in SVN:</p>
             <ul>
-              <li><a href="http://llvm.org/svn/llvm-project/lldb/trunk/examples/python/symbolication.py">symbolication.py</a></li>
-              <li><a href="http://llvm.org/svn/llvm-project/lldb/trunk/examples/python/crashlog.py">crashlog.py</a></li>
+              <li><a href="https://github.com/llvm/llvm-project/blob/master/lldb/examples/python/symbolication.py">symbolication.py</a></li>
+              <li><a href="https://github.com/llvm/llvm-project/blob/master/lldb/examples/python/crashlog.py">crashlog.py</a></li>
             </ul>
           </div>
           <div class="postfooter"></div>
         </div>
 </div>
 </body>
 </html>

lldb/www/varformats.html

(Rectangle) r3 = Area: 16, Perimeter: 16<br/>
             details on the API you should look at <a href="scripting.html">this page</a>, or at
             the LLDB <a href="docs.html">API reference documentation</a>.</p>
             
             <p>As a brief introduction, your script is encapsulated into a function that is
             passed two parameters: <code>valobj</code> and <code>internal_dict</code>.</p>
             
             <p><code>internal_dict</code> is an internal support parameter used by LLDB and you should
             not touch it.<br/><code>valobj</code> is the object encapsulating the actual
-            variable being displayed, and its type is <a href="http://llvm.org/svn/llvm-project/lldb/trunk/include/lldb/API/SBValue.h">SBValue</a>.
+            variable being displayed, and its type is <a href="https://github.com/llvm/llvm-project/blob/master/lldb/include/lldb/API/SBValue.h">SBValue</a>.
       Out of the many possible operations on an SBValue, the basic one is retrieve the children objects
             it contains (essentially, the fields of the object wrapped by it), by calling
             <code>GetChildMemberWithName()</code>, passing it the child's name as a string.<br/>
             If the variable has a value, you can ask for it, and return it as a string using <code>GetValue()</code>,
             or as a signed/unsigned number using <code>GetValueAsSigned()</code>, <code>GetValueAsUnsigned()</code>.
-      It is also possible to retrieve an <a href="http://llvm.org/svn/llvm-project/lldb/trunk/include/lldb/API/SBData.h"><code>SBData</code></a> object by calling <code>GetData()</code> and then read
+      It is also possible to retrieve an <a href="https://github.com/llvm/llvm-project/blob/master/lldb/include/lldb/API/SBData.h"><code>SBData</code></a> object by calling <code>GetData()</code> and then read
       the object's contents out of the <code>SBData</code>.
             
             <p>If you need to delve into several levels of hierarchy, as you can do with summary
             strings, you can use the method <code>GetValueForExpressionPath()</code>, passing it
             an expression path just like those you could use for summary strings (one of the differences
       is that dereferencing a pointer does not occur by prefixing the path with a <code>*</code>,
       but by calling the <code>Dereference()</code> method on the returned SBValue).
       If you need to access array slices, you cannot do that (yet) via this method call, and you must
(Rectangle) r3 = Area: 16, Perimeter: 16<br/>
                 could also use regular expressions to catch other type
                 sets grouped by name. However, as regular expression
                 matching is slower than normal name matching, LLDB will
                 first try to match by name in any way it can, and only
                 when this fails, will it resort to regular expression
                 matching. </p>
         <p>One of the ways LLDB uses this feature internally, is to match
           the names of STL container classes, regardless of the template
-          arguments provided. The details for this are found at <a href="http://llvm.org/svn/llvm-project/lldb/trunk/source/DataFormatters/FormatManager.cpp">FormatManager.cpp</a></p>
+          arguments provided. The details for this are found at <a href="https://github.com/llvm/llvm-project/blob/master/lldb/source/DataFormatters/FormatManager.cpp">FormatManager.cpp</a></p>
 
               <p>The regular expression language used by LLDB is the <a href="http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions">POSIX extended language</a>, as defined by the <a href="http://pubs.opengroup.org/onlinepubs/7908799/xsh/regex.h.html">Single UNIX Specification</a>, of which Mac OS X is a
   compliant implementation.
 
             </div>
           </div>
           
         <div class="post">
&nbsp;&nbsp;&nbsp;&nbsp;}<br/>
       
     </code>
 <sup>[1]</sup> This method is optional. Also, it may optionally choose to return a value (starting with SVN rev153061/LLDB-134). If it returns a value, and that value is <font color=blue><code>True</code></font>, LLDB will be allowed to cache the children and the children count it previously obtained, and will not return to the provider class to ask. If nothing, <font color=blue><code>None</code></font>, or anything other than <font color=blue><code>True</code></font> is returned, LLDB will discard the cached information and ask. Regardless, whenever necessary LLDB will call <code>update</code>.
 <br/>
 <sup>[2]</sup> This method is optional (starting with SVN rev166495/LLDB-175). While implementing it in terms of <code>num_children</code> is acceptable, implementors are encouraged to look for optimized coding alternatives whenever reasonable.
 <br/>
 <sup>[3]</sup> This method is optional (starting with SVN revision 219330). The SBValue you return here will most likely be a numeric type (int, float, ...) as its value bytes will be used as-if they were the value of the root SBValue proper. As a shortcut for this, you can inherit from lldb.SBSyntheticValueProvider, and just define get_value as other methods are defaulted in the superclass as returning default no-children responses.
 <p>If a synthetic child provider supplies a special child named <code>$$dereference$$</code> then it will be used when evaluating <code>opertaor*</code> and <code>operator-&gt;</code> in the <code>frame variable</code> command and related SB API functions.</p>
-    <p>For examples of how synthetic children are created, you are encouraged to look at <a href="http://llvm.org/svn/llvm-project/lldb/trunk/examples/synthetic/">examples/synthetic</a> in the LLDB trunk. Please, be aware that the code in those files (except bitfield/)
+    <p>For examples of how synthetic children are created, you are encouraged to look at <a href="https://github.com/llvm/llvm-project/blob/master/lldb/examples/synthetic/">examples/synthetic</a> in the LLDB sources. Please, be aware that the code in those files (except bitfield/)
       is legacy code and is not maintained.
-      You may especially want to begin looking at <a href="http://llvm.org/svn/llvm-project/lldb/trunk/examples/synthetic/bitfield">this example</a> to get
+      You may especially want to begin looking at <a href="https://github.com/llvm/llvm-project/blob/master/lldb/examples/synthetic/bitfield/">this example</a> to get
       a feel for this feature, as it is a very easy and well commented example.</p>
       The design pattern consistently used in synthetic providers shipping with LLDB
         is to use the <code>__init__</code> to store the SBValue instance as a part of <code>self</code>. The <code>update</code> function is then used
         to perform the actual initialization.
         
         
     <p>Once a synthetic children provider is written, one must load it into LLDB before it can be used.
       Currently, one can use the LLDB <code>script</code> command to type Python code interactively,
By default, LLDB will not show you the real type of the object. it can actually dynamically discover the type of an Objective-C
                       </td>
               </table>
               <code>(__NSCFString *) $1 = 0x00000001048000b0 @&quot;Hello&quot;<br/>
               </code>
           <p>
             Because LLDB uses a detection algorithm that does not need to invoke any functions
             on the target process, <code>no-run-target</code> is enough for this to work.</p>
             As a side note, the summary for NSString shown in the example is built right into LLDB.
-      It was initially implemented through Python (the code is still available for reference at <a href="http://llvm.org/svn/llvm-project/lldb/trunk/examples/summaries/cocoa/CFString.py">CFString.py</a>).
+      It was initially implemented through Python (the code is still available for reference at <a href="https://github.com/llvm/llvm-project/blob/master/lldb/examples/summaries/cocoa/CFString.py">CFString.py</a>).
       However, this is out of sync with the current implementation of the NSString formatter (which is a C++ function compiled into the LLDB core).
       </p>
           </div>
         </div>
 
         <div class="post">
           <h1 class="postheader">Categories</h1>
           <div class="postcontent">          
By default, LLDB will not show you the real type of the object. it can actually dynamically discover the type of an Objective-C
           type is displayed. The reason the debugger warns you is that enabling an empty category might be a typo, and you
           effectively wanted to enable a similarly-named but not-empty category.</p>
           </div>
         </div>
 
           <div class="post">
             <h1 class="postheader">Finding formatters 101</h1>
             <div class="postcontent">
-              <p>Searching for a formatter
-               (including formats, starting in SVN rev <a href="http://llvm.org/viewvc/llvm-project?view=revision&amp;revision=192217">r192217</a>)
-              given a variable goes through
+              <p>Searching for a formatter given a variable goes through
         a rather intricate set of rules. Namely, what happens is that LLDB
         starts looking in each enabled category, according to the order in which
         they were enabled (latest enabled first). In each category, LLDB does
         the following:</p>
               <ul>
                 <li>If there is a formatter for the type of the variable,
                   use it</li>
                 <li>If this object is a pointer, and there is a formatter

llgo/README.TXT

 * A modern C++ toolchain (to build LLVM).
   http://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain
 
 Note that Ubuntu Precise is one Linux distribution which does not package
 a sufficiently new CMake or C++ toolchain.
 
 To build and install llgo:
 
-    # Checkout LLVM:
-    svn co http://llvm.org/svn/llvm-project/llvm/trunk /path/to/llvm
-
-    # Checkout Clang:
-    cd /path/to/llvm/tools
-    svn co http://llvm.org/svn/llvm-project/cfe/trunk clang
-
-    # Checkout llgo:
-    svn co http://llvm.org/svn/llvm-project/llgo/trunk llgo
+    # Checkout llvm project.
+    git clone https://github.com/llvm/llvm-project.git
 
     # Build LLVM, Clang and llgo: (see also http://llvm.org/docs/CMake.html)
-    mkdir /path/to/llvm-build
-    cd /path/to/llvm-build
-    cmake /path/to/llvm -DCMAKE_INSTALL_PREFIX=/path/to/llvm-inst
+    cd llvm-project
+    mkdir build
+    cd build
+    cmake ../llvm -DLLVM_ENABLE_PROJECTS='clang;llgo' -DCMAKE_INSTALL_PREFIX=/path/to/llvm-inst
     make install
 
 Running
 -------
 
 llgo-go is llgo's version of the "go" command. It has the same command line
 interface as go, and works the same way, but it uses llgo to compile.
 

llvm/docs/CompileCudaWithLLVM.rst

 
 In clang and nvcc, most of the C++ standard library is not supported on the
 device side.
 
 ``<math.h>`` and ``<cmath>``
 ----------------------------
 
 In clang, ``math.h`` and ``cmath`` are available and `pass
-<https://github.com/llvm-mirror/test-suite/blob/master/External/CUDA/math_h.cu>`_
+<https://github.com/llvm/llvm-test-suite/blob/master/External/CUDA/math_h.cu>`_
 `tests
-<https://github.com/llvm-mirror/test-suite/blob/master/External/CUDA/cmath.cu>`_
+<https://github.com/llvm/llvm-test-suite/blob/master/External/CUDA/cmath.cu>`_
 adapted from libc++'s test suite.
 
 In nvcc ``math.h`` and ``cmath`` are mostly available.  Versions of ``::foof``
 in namespace std (e.g. ``std::sinf``) are not available, and where the standard
 calls for overloads that take integral arguments, these are usually not
 available.
 
 .. code-block:: c++

llvm/docs/LibFuzzer.rst

.. code-block:: console
 
   ./afl-fuzz -i testcase_dir -o findings_dir /path/to/program @@
   ./llvm-fuzz testcase_dir findings_dir  # Will write new tests to testcase_dir
 
 Periodically restart both fuzzers so that they can use each other's findings.
 Currently, there is no simple way to run both fuzzing engines in parallel while sharing the same corpus dir.
 
 You may also use AFL on your target function ``LLVMFuzzerTestOneInput``:
-see an example `here <https://github.com/llvm-mirror/compiler-rt/tree/master/lib/fuzzer/afl>`__.
+see an example `here <https://github.com/llvm/llvm-project/tree/master/compiler-rt/lib/fuzzer/afl>`__.
 
 How good is my fuzzer?
 ----------------------
 
 Once you implement your target function ``LLVMFuzzerTestOneInput`` and fuzz it to death,
 you will want to know whether the function or the corpus can be improved further.
 One easy to use metric is, of course, code coverage.
 

 .. _pcre2: http://www.pcre.org/
 .. _AFL: http://lcamtuf.coredump.cx/afl/
 .. _Radamsa: https://github.com/aoh/radamsa
 .. _SanitizerCoverage: http://clang.llvm.org/docs/SanitizerCoverage.html
 .. _SanitizerCoverageTraceDataFlow: http://clang.llvm.org/docs/SanitizerCoverage.html#tracing-data-flow
 .. _AddressSanitizer: http://clang.llvm.org/docs/AddressSanitizer.html
 .. _LeakSanitizer: http://clang.llvm.org/docs/LeakSanitizer.html
 .. _Heartbleed: http://en.wikipedia.org/wiki/Heartbleed
-.. _FuzzerInterface.h: https://github.com/llvm-mirror/compiler-rt/blob/master/lib/fuzzer/FuzzerInterface.h
+.. _FuzzerInterface.h: https://github.com/llvm/llvm-project/blob/master/compiler-rt/lib/fuzzer/FuzzerInterface.h
 .. _3.7.0: http://llvm.org/releases/3.7.0/docs/LibFuzzer.html
 .. _building Clang from trunk: http://clang.llvm.org/get_started.html
 .. _MemorySanitizer: http://clang.llvm.org/docs/MemorySanitizer.html
 .. _UndefinedBehaviorSanitizer: http://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html
 .. _`coverage counters`: http://clang.llvm.org/docs/SanitizerCoverage.html#coverage-counters
 .. _`value profile`: #value-profile
 .. _`caller-callee pairs`: http://clang.llvm.org/docs/SanitizerCoverage.html#caller-callee-coverage
 .. _BoringSSL: https://boringssl.googlesource.com/boringssl/
 

llvm/docs/TestSuiteGuide.md

1. The lit test runner is required to run the tests. You can either use one
    % pip install svn+http://llvm.org/svn/llvm-project/llvm/trunk/utils/lit
    % lit --version
    lit 0.8.0dev
    ```
 
 2. Check out the `test-suite` module with:
 
    ```bash
-   % svn co http://llvm.org/svn/llvm-project/test-suite/trunk test-suite
+   % git clone https://github.com/llvm/llvm-test-suite.git test-suite
    ```
 
 3. Create a build directory and use CMake to configure the suite. Use the
    `CMAKE_C_COMPILER` option to specify the compiler to test. Use a cache file
    to choose a typical build configuration:
 
    ```bash
    % mkdir test-suite-build

llvm/docs/TestSuiteMakefileGuide.rst

 ======================================
 test-suite Makefile Guide (deprecated)
 ======================================
 
 .. contents::
     :local:
 
 Overview
 ========
 
 First, all tests are executed within the LLVM object directory tree.
 They *are not* executed inside of the LLVM source tree. This is because
 the test suite creates temporary files during execution.
 
 To run the test suite, you need to use the following steps:
 
-#. ``cd`` into the ``llvm/projects`` directory in your source tree.
 #. Check out the ``test-suite`` module with:
 
    .. code-block:: bash
 
-       % svn co http://llvm.org/svn/llvm-project/test-suite/trunk test-suite
+       % git clone https://github.com/llvm/llvm-test-suite.git test-suite
 
-   This will get the test suite into ``llvm/projects/test-suite``.
+#. FIXME: these directions are outdated and won't work. Figure out
+   what the correct thing to do is, and write it down here.
 
 #. Configure and build ``llvm``.
 
 #. Configure and build ``llvm-gcc``.
 
 #. Install ``llvm-gcc`` somewhere.
 
 #. *Re-configure* ``llvm`` from the top level of each build tree (LLVM

llvm/docs/TestingGuide.rst

.. code-block:: bash
     % llvm-lit ~/llvm/test/CodeGen/ARM
 
 For more information on using the :program:`lit` tool, see ``llvm-lit --help``
 or the :doc:`lit man page <CommandGuide/lit>`.
 
 Debugging Information tests
 ---------------------------
 
-To run debugging information tests simply checkout the tests inside
-clang/test directory.
-
-.. code-block:: bash
-
-    % cd clang/test
-    % svn co http://llvm.org/svn/llvm-project/debuginfo-tests/trunk debuginfo-tests
-
-These tests are already set up to run as part of clang regression tests.
+To run debugging information tests simply add the ``debuginfo-tests``
+project to your ``LLVM_ENABLE_PROJECTS`` define on the cmake
+command-line.
 
 Regression test structure
 =========================
 
 The LLVM regression tests are driven by :program:`lit` and are located in the
 ``llvm/test`` directory.
 
 This directory contains a large array of small tests that exercise

llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

bool TargetLowering::expandFP_TO_SINT(SDNode *Node, SDValue &Result,
   SDLoc dl(SDValue(Node, 0));
 
   // FIXME: Only f32 to i64 conversions are supported.
   if (SrcVT != MVT::f32 || DstVT != MVT::i64)
     return false;
 
   // Expand f32 -> i64 conversion
   // This algorithm comes from compiler-rt's implementation of fixsfdi:
-  // https://github.com/llvm-mirror/compiler-rt/blob/master/lib/builtins/fixsfdi.c
+  // https://github.com/llvm/llvm-project/blob/master/compiler-rt/lib/builtins/fixsfdi.c
   unsigned SrcEltBits = SrcVT.getScalarSizeInBits();
   EVT IntVT = SrcVT.changeTypeToInteger();
   EVT IntShVT = getShiftAmountTy(IntVT, DAG.getDataLayout());
 
   SDValue ExponentMask = DAG.getConstant(0x7F800000, dl, IntVT);
   SDValue ExponentLoBit = DAG.getConstant(23, dl, IntVT);
   SDValue Bias = DAG.getConstant(127, dl, IntVT);
   SDValue SignMask = DAG.getConstant(APInt::getSignMask(SrcEltBits), dl, IntVT);

llvm/lib/Target/AMDGPU/AMDGPUISelLowering.h

void ReplaceNodeResults(SDNode * N,
                           SelectionDAG &DAG) const override;
 
   SDValue combineFMinMaxLegacy(const SDLoc &DL, EVT VT, SDValue LHS,
                                SDValue RHS, SDValue True, SDValue False,
                                SDValue CC, DAGCombinerInfo &DCI) const;
 
   const char* getTargetNodeName(unsigned Opcode) const override;
 
-  // FIXME: Turn off MergeConsecutiveStores() before Instruction Selection
-  // for AMDGPU.
-  // A commit ( git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@319036
-  // 91177308-0d34-0410-b5e6-96231b3b80d8 ) turned on
-  // MergeConsecutiveStores() before Instruction Selection for all targets.
-  // Enough AMDGPU compiles go into an infinite loop ( MergeConsecutiveStores()
-  // merges two stores; LegalizeStoreOps() un-merges; MergeConsecutiveStores()
-  // re-merges, etc. ) to warrant turning it off for now.
+  // FIXME: Turn off MergeConsecutiveStores() before Instruction Selection for
+  // AMDGPU.  Commit r319036,
+  // (https://github.com/llvm/llvm-project/commit/db77e57ea86d941a4262ef60261692f4cb6893e6)
+  // turned on MergeConsecutiveStores() before Instruction Selection for all
+  // targets.  Enough AMDGPU compiles go into an infinite loop (
+  // MergeConsecutiveStores() merges two stores; LegalizeStoreOps() un-merges;
+  // MergeConsecutiveStores() re-merges, etc. ) to warrant turning it off for
+  // now.
   bool mergeStoresAfterLegalization() const override { return false; }
 
   bool isFsqrtCheap(SDValue Operand, SelectionDAG &DAG) const override {
     return true;
   }
   SDValue getSqrtEstimate(SDValue Operand, SelectionDAG &DAG, int Enabled,
                            int &RefinementSteps, bool &UseOneConstNR,
                            bool Reciprocal) const override;

llvm/test/CodeGen/PowerPC/pr24546.ll

 attributes #1 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="ppc64le" "target-features"="+altivec,+bpermd,+crypto,+direct-move,+extdiv,+power8-vector,+vsx,-qpx" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #2 = { nounwind readnone }
 attributes #3 = { nounwind }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!29, !30}
 !llvm.ident = !{!31}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.8.0 (git://github.com/llvm-mirror/clang.git e0848b6353721eb1b278a5bbea257bbf6316251e) (git://github.com/llvm-mirror/llvm.git 8724a428dfd5e78d7865bb01783708e83f9ed128)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !3, globals: !23)
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.8.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !3, globals: !23)
 !1 = !DIFile(filename: "testcase.i", directory: "/tmp/glibc.build")
 !2 = !{}
 !3 = !{!4}
 !4 = !DIBasicType(name: "double", size: 64, align: 64, encoding: DW_ATE_float)
 !6 = distinct !DISubprogram(name: "_php_math_round", scope: !1, file: !1, line: 15, type: !7, isLocal: false, isDefinition: true, scopeLine: 16, flags: DIFlagPrototyped, isOptimized: true, unit: !0, retainedNodes: !10)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!4, !4, !9, !9}
 !9 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)

 !23 = !{!24}
 !24 = !DIGlobalVariableExpression(var: !DIGlobalVariable(name: "powers", scope: !18, file: !1, line: 3, type: !25, isLocal: true, isDefinition: true), expr: !DIExpression())
 !25 = !DICompositeType(tag: DW_TAG_array_type, baseType: !26, size: 1472, align: 64, elements: !27)
 !26 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !4)
 !27 = !{!28}
 !28 = !DISubrange(count: 23)
 !29 = !{i32 2, !"Dwarf Version", i32 4}
 !30 = !{i32 2, !"Debug Info Version", i32 3}
-!31 = !{!"clang version 3.8.0 (git://github.com/llvm-mirror/clang.git e0848b6353721eb1b278a5bbea257bbf6316251e) (git://github.com/llvm-mirror/llvm.git 8724a428dfd5e78d7865bb01783708e83f9ed128)"}
+!31 = !{!"clang version 3.8.0"}
 !32 = !DILocation(line: 21, column: 32, scope: !33)
 !33 = distinct !DILexicalBlock(scope: !6, file: !1, line: 21, column: 6)
 !34 = !DILocation(line: 22, column: 15, scope: !35)
 !35 = distinct !DILexicalBlock(scope: !33, file: !1, line: 21, column: 67)
 !36 = !DILocation(line: 8, column: 16, scope: !37, inlinedAt: !38)
 !37 = distinct !DILexicalBlock(scope: !18, file: !1, line: 8, column: 6)
 !38 = distinct !DILocation(line: 23, column: 8, scope: !35)
 !39 = !DILocation(line: 9, column: 10, scope: !40, inlinedAt: !38)

llvm/utils/lit/setup.py

 
 The official *lit* documentation is in the man page, available online at the LLVM
 Command Guide: http://llvm.org/cmds/lit.html.
 
 
 Source
 ======
 
-The *lit* source is available as part of LLVM, in the LLVM SVN repository:
-http://llvm.org/svn/llvm-project/llvm/trunk/utils/lit.
+The *lit* source is available as part of LLVM, in the LLVM source repository:
+https://github.com/llvm/llvm-project/tree/master/llvm/utils/lit
 """,
 
     classifiers=[
         'Development Status :: 3 - Alpha',
         'Environment :: Console',
         'Intended Audience :: Developers',
         'License :: OSI Approved :: Apache-2.0 with LLVM exception',
         'Natural Language :: English',

openmp/www/index.html

<div class="submenu">
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="http://lists.llvm.org/mailman/listinfo/openmp-dev">openmp-dev</a>
     <a href="http://lists.llvm.org/mailman/listinfo/openmp-commits">openmp-commits</a>
     <a href="http://llvm.org/bugs/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/openmp/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/openmp/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/openmp">Browse Sources</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>OpenMP&reg;: Support for the OpenMP language</h1>
   <!--*********************************************************************-->
 
<a href="http://www.openmp.org/mp-documents/OpenMP4.0.0.pdf">OpenMP
   <!--=====================================================================-->
 
   <p>First please review our
      <a href="http://llvm.org/docs/DeveloperPolicy.html">Developer's Policy</a>.
 
   <p>To check out the code, use:</p>
 
   <ul>
-  <li><code>svn co http://llvm.org/svn/llvm-project/openmp/trunk openmp</code></li>
+  <li><code>git clone https://github.com/llvm/llvm-project.git</code></li>
   </ul>
 
-  <p>
-     Note that for an in-tree build, you should check out openmp to llvm/projects.
-  </p>
-
   <p>In-tree build:</p>
   <ul>
-    <li><code>cd where-you-want-to-live</code></li>
-    <li>Check out openmp into llvm/projects</li>
-    <li><code>cd where-you-want-to-build</code></li>
+    <li><code>cd llvm-project</code></li>
     <li><code>mkdir build &amp;&amp; cd build</code></li>
-    <li><code>cmake path/to/llvm -DCMAKE_C_COMPILER=&lt;C compiler&gt; -DCMAKE_CXX_COMPILER=&lt;C++ compiler&gt;</code></li>
+    <li><code>cmake ../llvm -DLLVM_ENABLE_PROJECTS=openmp -DCMAKE_C_COMPILER=&lt;C compiler&gt; -DCMAKE_CXX_COMPILER=&lt;C++ compiler&gt;</code></li>
     <li><code>make omp</code></li>
   </ul>
 
   <p>Out-of-tree build:</p>
   <ul>
-    <li><code>cd where-you-want-to-live</code></li>
-    <li>Check out openmp</li>
-    <li><code>cd where-you-want-to-live/openmp</code></li>
-    <li><code>mkdir build &amp;&amp; cd build</code></li>
-    <li><code>cmake path/to/openmp -DCMAKE_C_COMPILER=&lt;C compiler&gt; -DCMAKE_CXX_COMPILER=&lt;C++ compiler&gt;</code></li>
+    <li><code>cd llvm-project</code></li>
+    <li><code>mkdir build-openmp &amp;&amp; cd build-openmp</code></li>
+    <li><code>cmake ../openmp -DCMAKE_C_COMPILER=&lt;C compiler&gt; -DCMAKE_CXX_COMPILER=&lt;C++ compiler&gt;</code></li>
     <li><code>make</code></li>
   </ul>
 
   <p>Full details of how to build are in the
     <a href="README.txt">README.txt</a> and README.rst in the source code repository.
   </p>
 
   <!--=====================================================================-->

polly/docs/TipsAndTricks.rst

 --------------------------------------------------------------
 
 In case of a regression in performance or correctness (e.g., an earlier version
 of Polly behaved as expected and a later version does not), bisecting over the
 version history is the standard approach to identify the commit that introduced
 the regression.
 
 LLVM has a single repository that contains all projects. It can be cloned at:
-`<https://github.com/llvm-project/llvm-project-20170507>`_. How to bisect on a
+`<https://github.com/llvm/llvm-project>`_. How to bisect on a
 git repository is explained here
 `<https://www.metaltoad.com/blog/beginners-guide-git-bisect-process-elimination>`_.
 The bisect process can also be automated as explained here:
 `<https://www.metaltoad.com/blog/mechanizing-git-bisect-bug-hunting-lazy>`_.
 An LLVM specific run script is available here:
 `<https://gist.github.com/dcci/891cd98d80b1b95352a407d80914f7cf>`_.

polly/www/get_started.html

 wget http://polly.llvm.org/polly.sh
 chmod +x polly.sh
 ./polly.sh
 </pre>
 
 <h2> Manual </h2>
 <h3 id="source"> Get the code </h3>
 
-<p><b>Warning:</b> Polly/LLVM/clang need to be checked out at the same time.</p>
-
 <pre>
-git clone http://llvm.org/git/llvm.git llvm_git
-git clone http://llvm.org/git/polly.git llvm_git/tools/polly
-
-# Also build the matching clang-version (optional)
-git clone http://llvm.org/git/clang.git llvm_git/tools/clang
+git clone http://github.com/llvm/llvm-project.git llvm_git
 </pre>
 <h3 id="build">Build Polly</h3>
 
 <pre>
 mkdir llvm_build && cd llvm_build
-cmake ../llvm_git && make
+cmake -DLLVM_ENABLE_PROJECTS='polly;clang' ../llvm_git/llvm && make
 </pre>
 
 <h3> Test Polly</h3>
 
 <pre>make check-polly</pre>
 
 <h3>Building Polly Without LLVM</h3>
 It is also possible to build Polly without
 also building LLVM. All you need is an installed version of LLVM or a previous
 build. To configure Polly to use a pre-built LLVM, set the
 <code>-DCMAKE_PREFIX_PATH</code> option:
 
-<pre>cmake -DCMAKE_PREFIX_PATH=${LLVM_PREFIX}/lib/cmake/llvm</pre>
+<pre>cmake -DCMAKE_PREFIX_PATH=${LLVM_PREFIX}/lib/cmake/llvm ../llvm_git/polly</pre>
 
 To run unittests, however, you need to have the LLVM source directory around.
 Polly will use the <code>llvm-config</code> of the LLVM you're building against
 to guess the location of the source directory. You may override autodetected
 location by setting the <code>-DLLVM_SOURCE_ROOT</code> option.
 
 <h3> Troubleshooting</h3>
 

polly/www/menu.html.incl

<a href="http://lists.llvm.org/mailman/listinfo/llvm-commits">
       Mailing List (patches)
     </a>
     <a href="http://groups.google.com/group/polly-dev">Mailing List (discussion)</a>
     <a href="/bugs.html">Bug Reports</a>
     <a href="http://lab.llvm.org:8011/console?category=polly">Buildbot</a>
     <a href="http://lab.llvm.org:8080/coverage/coverage-reports/polly/index.html">Code Coverage</a>
     <a href="http://llvm.org/reports/scan-build/">Static analysis</a>
     <a href="/doxygen/">Doxygen</a>
-    <a href="https://github.com/llvm-mirror/polly">Source @ GitHub</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/polly">Source @ GitHub</a>
   </div>
 
   <div class="submenu">
     <label>Resources</label>
     <br>
     <a href="https://www.pollylabs.org"><img style="padding-left: 3.5em;
     padding-right: 1em; width:10em" src="/images/pollylabs.png" /></a>
     <div class="container" style="width: 240px">

polly/www/todo.html

 </th><td class="done" align="center">
 <a
 href="http://llvm.org/svn/llvm-project/polly"
 >http://llvm.org/svn/llvm-project/polly</a>
 </td><td> Tobias
 
 </td></tr>
 <tr>
-<th align="left"> Git mirror
-</th><td class="done" align="center">
-git://llvm.org/git/polly.git
-</td><td> Tobias
-</td></tr>
-<tr>
 <th align="left"> Commit mails
 </th><td class="done" align="center">
 [e-mail]
 </td><td> Tobias
 </td></tr>
 <tr>
 
 <th align="left"> LLVM Bugzilla category