EpicGames
/
DirectXShaderCompiler
зеркало из https://github.com/EpicGames/DirectXShaderCompiler.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Revert license text in banner comments to original llvm verbage (#33) 

Fix #30: Revert license text in banner comments to original llvm verbage

This commit removes the Microsoft-specific copyright in llvm files
and reverts the copyright wording to the original llvm wording.

We used the following method to find the files to change:
1. Find all files in DirectXShaderCompiler that are also in llvm 3.7
2. For those files that have the Microsoft-specific copyright, revert
   it to the original llvm copyright as present in llvm 3.7
3. Revert the copyright in a few files that are not in llvm, but are
   mostly copies of files in llvm:
	lib\Transforms\Scalar\ScalarReplAggregatesHLSL.cpp
	lib\Transforms\Scalar\Reg2MemHLSL.cpp

Leave the Microsoft-specific copyright header in files not present
in stock llvm:

    include\dxc\*
    lib\HLSL\*
    lib\DxcSupport\*
    tools\clang\test\HLSL\*
    tools\clang\test\CodeGenHLSL\*
    tools\clang\unittests\HLSL\*
    tools\clang\unittests\HLSLHost\*
    tools\clang\tools\dxcompiler\*
    tools\clang\tools\dxa\*
    tools\clang\tools\dxc\*
    tools\clang\tools\dxopt\*
    tools\clang\tools\dxr\*
    tools\clang\tools\dxv\*
    tools\clang\tools\dotnetc\*
    utils\hct\*
    CONTRIBUTING.md
    COPYRIGHT
    LICENSE-MIT
    README.md
    cmake\modules\FindD3D12.cmake
    cmake\modules\FindDiaSDK.cmake
    cmake\modules\FindTAEF.cmake
    docs\DXIL.rst
    docs\HLSLChanges.rst
    docs\_themes\dxc-theme\layout.html
    docs\_themes\dxc-theme\theme.conf
    docs\_themes\dxc-theme\static\dxc-theme.css
    include\llvm\llvm_assert\assert.h
    include\llvm\llvm_assert\cassert
    include\llvm\Support\MSFileSystem.h
    include\llvm\Support\OacrIgnoreCond.h
    lib\MSSupport\CMakeLists.txt
    lib\MSSupport\MSFileSystemImpl.cpp
    lib\Support\assert.cpp
    lib\Support\MSFileSystemBasic.cpp
    lib\Support\Windows\MSFileSystem.inc.cpp
    lib\Transforms\Scalar\Reg2MemHLSL.cpp
    lib\Transforms\Scalar\ScalarReplAggregatesHLSL.cpp
    tools\clang\docs\UsingDxc.rst
    tools\clang\include\clang\AST\HlslTypes.h
    tools\clang\include\clang\Basic\BuiltinsDXIL.def
    tools\clang\include\clang\Basic\LangOptions.fixed.def
    tools\clang\include\clang\Parse\ParseHLSL.h
    tools\clang\include\clang\Sema\SemaHLSL.h
    tools\clang\lib\AST\ASTContextHLSL.cpp
    tools\clang\lib\AST\HlslTypes.cpp
    tools\clang\lib\CodeGen\CGHLSLMS.cpp
    tools\clang\lib\CodeGen\CGHLSLRuntime.cpp
    tools\clang\lib\CodeGen\CGHLSLRuntime.h
    tools\clang\lib\Frontend\Rewrite\FrontendActions_rewrite.cpp
    tools\clang\lib\Parse\HLSLRootSignature.cpp
    tools\clang\lib\Parse\HLSLRootSignature.h
    tools\clang\lib\Parse\ParseHLSL.cpp
    tools\clang\lib\Sema\gen_intrin_main_tables_15.h
    tools\clang\lib\Sema\SemaHLSL.cpp
    tools\clang\tools\d3dcomp\CMakeLists.txt
    tools\clang\tools\d3dcomp\d3dcomp.cpp
    tools\clang\tools\d3dcomp\d3dcomp.def
    tools\clang\tools\libclang\dxcisenseimpl.cpp
    tools\clang\tools\libclang\dxcisenseimpl.h
    tools\clang\tools\libclang\dxcrewriteunused.cpp
    tools\clang\tools\libclang\libclang.rc
    tools\dxexp\CMakeLists.txt
    tools\dxexp\dxexp.cpp
    tools\dxexp\LLVMBuild.txt
This commit is contained in:
David Peixotto 2017-01-24 17:54:00 -08:00 коммит произвёл GitHub
Родитель 5623234187
Коммит f805233b49
3412 изменённых файлов: 36854 добавлений и 35402 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
CMakeLists.txt
Просмотреть файл

@ -1,5 +1,3 @@
# Copyright (C) Microsoft Corporation. All rights reserved.
# Licensed under the MIT license. See COPYRIGHT in the project root for full license information.
# See docs/CMake.html for instructions about how to build LLVM with CMake.
cmake_minimum_required(VERSION 2.8.12.2)

70
LICENSE.TXT Normal file
Просмотреть файл

@ -0,0 +1,70 @@
==============================================================================
LLVM Release License
==============================================================================
University of Illinois/NCSA
Open Source License
Copyright (c) 2003-2015 University of Illinois at Urbana-Champaign.
All rights reserved.
Developed by:
LLVM Team
University of Illinois at Urbana-Champaign
http://llvm.org
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal with
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimers.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimers in the
documentation and/or other materials provided with the distribution.
* Neither the names of the LLVM Team, University of Illinois at
Urbana-Champaign, nor the names of its contributors may be used to
endorse or promote products derived from this Software without specific
prior written permission.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
SOFTWARE.
==============================================================================
Copyrights and Licenses for Third Party Software Distributed with LLVM:
==============================================================================
The LLVM software contains code written by third parties. Such software will
have its own individual LICENSE.TXT file in the directory in which it appears.
This file will describe the copyrights, license, and restrictions which apply
to that code.
The disclaimer of warranty in the University of Illinois Open Source License
applies to all code in the LLVM Distribution, and nothing in any of the
other licenses gives permission to use the names of the LLVM Team or the
University of Illinois to endorse or promote products derived from this
Software.
The following pieces of software have additional or alternate copyrights,
licenses, and/or restrictions:
Program Directory
------- ---------
Autoconf llvm/autoconf
llvm/projects/ModuleMaker/autoconf
Google Test llvm/utils/unittest/googletest
OpenBSD regex llvm/lib/Support/{reg*, COPYRIGHT.regex}
pyyaml tests llvm/test/YAMLParser/{*.data, LICENSE.TXT}
ARM contributions llvm/lib/Target/ARM/LICENSE.TXT
md5 contributions llvm/lib/Support/MD5.cpp llvm/include/llvm/Support/MD5.h

10
LLVMBuild.txt
Просмотреть файл

@ -1,5 +1,11 @@
; Copyright (C) Microsoft Corporation. All rights reserved.
; Licensed under the MIT license. See COPYRIGHT in the project root for full license information.
;===- ./LLVMBuild.txt ------------------------------------------*- Conf -*--===;
;
; The LLVM Compiler Infrastructure
;
; This file is distributed under the University of Illinois Open Source
; License. See LICENSE.TXT for details.
;
;===------------------------------------------------------------------------===;
;
; This is an LLVMBuild description file for the components in this subdirectory.
;

2
cmake/modules/CMakeLists.txt
Просмотреть файл

@ -1,5 +1,3 @@
# Copyright (C) Microsoft Corporation. All rights reserved.
# Licensed under the MIT license. See COPYRIGHT in the project root for full license information.
set(LLVM_INSTALL_PACKAGE_DIR share/llvm/cmake)
set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}")

6
docs/LLVMBuild.txt
Просмотреть файл

@ -1,7 +1,9 @@
;===- ./docs/LLVMBuild.txt -------------------------------------*- Conf -*--===;
;
; Copyright (C) Microsoft Corporation. All rights reserved.
; Licensed under the MIT license. See COPYRIGHT in the project root for full license information.
; The LLVM Compiler Infrastructure
;
; This file is distributed under the University of Illinois Open Source
; License. See LICENSE.TXT for details.
;
;===------------------------------------------------------------------------===;
;

2
examples/CMakeLists.txt
Просмотреть файл

@ -1,3 +1 @@
# Copyright (C) Microsoft Corporation. All rights reserved.
# Licensed under the MIT license. See COPYRIGHT in the project root for full license information.
add_subdirectory(ModuleMaker)

10
examples/LLVMBuild.txt
Просмотреть файл

@ -1,5 +1,11 @@
; Copyright (C) Microsoft Corporation. All rights reserved.
; Licensed under the MIT license. See COPYRIGHT in the project root for full license information.
;===- ./examples/LLVMBuild.txt ---------------------------------*- Conf -*--===;
;
; The LLVM Compiler Infrastructure
;
; This file is distributed under the University of Illinois Open Source
; License. See LICENSE.TXT for details.
;
;===------------------------------------------------------------------------===;
;
; This is an LLVMBuild description file for the components in this subdirectory.
;

2
examples/ModuleMaker/CMakeLists.txt
Просмотреть файл

@ -1,5 +1,3 @@
# Copyright (C) Microsoft Corporation. All rights reserved.
# Licensed under the MIT license. See COPYRIGHT in the project root for full license information.
set(LLVM_LINK_COMPONENTS
BitWriter
Core

25
examples/ModuleMaker/ModuleMaker.cpp
Просмотреть файл

@ -1,16 +1,17 @@
//===- examples/ModuleMaker/ModuleMaker.cpp - Example project ---*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// ModuleMaker.cpp //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This programs is a simple example that creates an LLVM module "from scratch",//
// emitting it as a bitcode file to standard out. This is just to show how //
// LLVM projects work and to demonstrate some of the LLVM APIs. //
// //
///////////////////////////////////////////////////////////////////////////////
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This programs is a simple example that creates an LLVM module "from scratch",
// emitting it as a bitcode file to standard out. This is just to show how
// LLVM projects work and to demonstrate some of the LLVM APIs.
//
//===----------------------------------------------------------------------===//
#include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/IR/Constants.h"

5
examples/ModuleMaker/README.txt
Просмотреть файл

@ -1,5 +1,6 @@
Copyright (C) Microsoft Corporation. All rights reserved.
Licensed under the MIT license. See COPYRIGHT in the project root for full licence information.
//===----------------------------------------------------------------------===//
// ModuleMaker Sample project
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
// ModuleMaker Sample project
//===----------------------------------------------------------------------===//

30
include/llvm-c/Analysis.h
Просмотреть файл

@ -1,18 +1,20 @@
/*===-- llvm-c/Analysis.h - Analysis Library C Interface --------*- C++ -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// Analysis.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to libLLVMAnalysis.a, which //
// implements various analyses of the LLVM IR. //
// Many exotic languages can interoperate with C code but have a harder time //
// with C++ due to name mangling. So in addition to C, this interface enables//
// tools written in such languages. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header declares the C interface to libLLVMAnalysis.a, which *|
|* implements various analyses of the LLVM IR. *|
|* *|
|* Many exotic languages can interoperate with C code but have a harder time *|
|* with C++ due to name mangling. So in addition to C, this interface enables *|
|* tools written in such languages. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_ANALYSIS_H
#define LLVM_C_ANALYSIS_H

30
include/llvm-c/BitReader.h
Просмотреть файл

@ -1,18 +1,20 @@
/*===-- llvm-c/BitReader.h - BitReader Library C Interface ------*- C++ -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// BitReader.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to libLLVMBitReader.a, which //
// implements input of the LLVM bitcode format. //
// Many exotic languages can interoperate with C code but have a harder time //
// with C++ due to name mangling. So in addition to C, this interface enables//
// tools written in such languages. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header declares the C interface to libLLVMBitReader.a, which *|
|* implements input of the LLVM bitcode format. *|
|* *|
|* Many exotic languages can interoperate with C code but have a harder time *|
|* with C++ due to name mangling. So in addition to C, this interface enables *|
|* tools written in such languages. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_BITREADER_H
#define LLVM_C_BITREADER_H

30
include/llvm-c/BitWriter.h
Просмотреть файл

@ -1,18 +1,20 @@
/*===-- llvm-c/BitWriter.h - BitWriter Library C Interface ------*- C++ -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// BitWriter.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to libLLVMBitWriter.a, which //
// implements output of the LLVM bitcode format. //
// Many exotic languages can interoperate with C code but have a harder time //
// with C++ due to name mangling. So in addition to C, this interface enables//
// tools written in such languages. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header declares the C interface to libLLVMBitWriter.a, which *|
|* implements output of the LLVM bitcode format. *|
|* *|
|* Many exotic languages can interoperate with C code but have a harder time *|
|* with C++ due to name mangling. So in addition to C, this interface enables *|
|* tools written in such languages. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_BITWRITER_H
#define LLVM_C_BITWRITER_H

23
include/llvm-c/Core.h
Просмотреть файл

@ -1,15 +1,16 @@
/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// Core.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to libLLVMCore.a, which implements //
// the LLVM intermediate representation. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header declares the C interface to libLLVMCore.a, which implements *|
|* the LLVM intermediate representation. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_CORE_H
#define LLVM_C_CORE_H

23
include/llvm-c/Disassembler.h
Просмотреть файл

@ -1,15 +1,16 @@
/*===-- llvm-c/Disassembler.h - Disassembler Public C Interface ---*- C -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// Disassembler.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header provides a public interface to a disassembler library. //
// LLVM provides an implementation of this interface. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header provides a public interface to a disassembler library. *|
|* LLVM provides an implementation of this interface. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_DISASSEMBLER_H
#define LLVM_C_DISASSEMBLER_H

30
include/llvm-c/ExecutionEngine.h
Просмотреть файл

@ -1,18 +1,20 @@
/*===-- llvm-c/ExecutionEngine.h - ExecutionEngine Lib C Iface --*- C++ -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// ExecutionEngine.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to libLLVMExecutionEngine.o, which //
// implements various analyses of the LLVM IR. //
// Many exotic languages can interoperate with C code but have a harder time //
// with C++ due to name mangling. So in addition to C, this interface enables//
// tools written in such languages. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header declares the C interface to libLLVMExecutionEngine.o, which *|
|* implements various analyses of the LLVM IR. *|
|* *|
|* Many exotic languages can interoperate with C code but have a harder time *|
|* with C++ due to name mangling. So in addition to C, this interface enables *|
|* tools written in such languages. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_EXECUTIONENGINE_H
#define LLVM_C_EXECUTIONENGINE_H

21
include/llvm-c/IRReader.h
Просмотреть файл

@ -1,14 +1,15 @@
/*===-- llvm-c/IRReader.h - IR Reader C Interface -----------------*- C -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// IRReader.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the C interface to the IR Reader. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This file defines the C interface to the IR Reader. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_IRREADER_H
#define LLVM_C_IRREADER_H

25
include/llvm-c/Initialization.h
Просмотреть файл

@ -1,16 +1,17 @@
/*===-- llvm-c/Initialization.h - Initialization C Interface ------*- C -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// Initialization.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to LLVM initialization routines, //
// which must be called before you can use the functionality provided by //
// the corresponding LLVM library. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header declares the C interface to LLVM initialization routines, *|
|* which must be called before you can use the functionality provided by *|
|* the corresponding LLVM library. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_INITIALIZATION_H
#define LLVM_C_INITIALIZATION_H

23
include/llvm-c/LinkTimeOptimizer.h
Просмотреть файл

@ -1,16 +1,17 @@
//===-- llvm/LinkTimeOptimizer.h - LTO Public C Interface -------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// LinkTimeOptimizer.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header provides a C API to use the LLVM link time optimization //
// library. This is intended to be used by linkers which are C-only in //
// their implementation for performing LTO. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This header provides a C API to use the LLVM link time optimization
// library. This is intended to be used by linkers which are C-only in
// their implementation for performing LTO.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_C_LINKTIMEOPTIMIZER_H
#define LLVM_C_LINKTIMEOPTIMIZER_H

21
include/llvm-c/Linker.h
Просмотреть файл

@ -1,14 +1,15 @@
/*===-- llvm-c/Linker.h - Module Linker C Interface -------------*- C++ -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// Linker.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the C interface to the module/file/archive linker. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This file defines the C interface to the module/file/archive linker. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_LINKER_H
#define LLVM_C_LINKER_H

31
include/llvm-c/Object.h
Просмотреть файл

@ -1,19 +1,20 @@
/*===-- llvm-c/Object.h - Object Lib C Iface --------------------*- C++ -*-===*/
///////////////////////////////////////////////////////////////////////////////
// //
// Object.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to libLLVMObject.a, which //
// implements object file reading and writing. //
// //
// Many exotic languages can interoperate with C code but have a harder time //
// with C++ due to name mangling. So in addition to C, this interface enables//
// tools written in such languages. //
// //
///////////////////////////////////////////////////////////////////////////////
/* */
/* The LLVM Compiler Infrastructure */
/* */
/* This file is distributed under the University of Illinois Open Source */
/* License. See LICENSE.TXT for details. */
/* */
/*===----------------------------------------------------------------------===*/
/* */
/* This header declares the C interface to libLLVMObject.a, which */
/* implements object file reading and writing. */
/* */
/* Many exotic languages can interoperate with C code but have a harder time */
/* with C++ due to name mangling. So in addition to C, this interface enables */
/* tools written in such languages. */
/* */
/*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_OBJECT_H
#define LLVM_C_OBJECT_H

21
include/llvm-c/Support.h
Просмотреть файл

@ -1,14 +1,15 @@
/*===-- llvm-c/Support.h - Support C Interface --------------------*- C -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// Support.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the C interface to the LLVM support library. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This file defines the C interface to the LLVM support library. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_SUPPORT_H
#define LLVM_C_SUPPORT_H

31
include/llvm-c/Target.h
Просмотреть файл

@ -1,19 +1,20 @@
/*===-- llvm-c/Target.h - Target Lib C Iface --------------------*- C++ -*-===*/
///////////////////////////////////////////////////////////////////////////////
// //
// Target.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to libLLVMTarget.a, which //
// implements target information. //
// //
// Many exotic languages can interoperate with C code but have a harder time //
// with C++ due to name mangling. So in addition to C, this interface enables//
// tools written in such languages. //
// //
///////////////////////////////////////////////////////////////////////////////
/* */
/* The LLVM Compiler Infrastructure */
/* */
/* This file is distributed under the University of Illinois Open Source */
/* License. See LICENSE.TXT for details. */
/* */
/*===----------------------------------------------------------------------===*/
/* */
/* This header declares the C interface to libLLVMTarget.a, which */
/* implements target information. */
/* */
/* Many exotic languages can interoperate with C code but have a harder time */
/* with C++ due to name mangling. So in addition to C, this interface enables */
/* tools written in such languages. */
/* */
/*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_TARGET_H
#define LLVM_C_TARGET_H

30
include/llvm-c/TargetMachine.h
Просмотреть файл

@ -1,18 +1,20 @@
/*===-- llvm-c/TargetMachine.h - Target Machine Library C Interface - C++ -*-=*\
///////////////////////////////////////////////////////////////////////////////
// //
// TargetMachine.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to the Target and TargetMachine //
// classes, which can be used to generate assembly or object files. //
// Many exotic languages can interoperate with C code but have a harder time //
// with C++ due to name mangling. So in addition to C, this interface enables//
// tools written in such languages. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header declares the C interface to the Target and TargetMachine *|
|* classes, which can be used to generate assembly or object files. *|
|* *|
|* Many exotic languages can interoperate with C code but have a harder time *|
|* with C++ due to name mangling. So in addition to C, this interface enables *|
|* tools written in such languages. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_TARGETMACHINE_H
#define LLVM_C_TARGETMACHINE_H

23
include/llvm-c/Transforms/IPO.h
Просмотреть файл

@ -1,15 +1,16 @@
/*===-- IPO.h - Interprocedural Transformations C Interface -----*- C++ -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// IPO.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to libLLVMIPO.a, which implements //
// various interprocedural transformations of the LLVM IR. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header declares the C interface to libLLVMIPO.a, which implements *|
|* various interprocedural transformations of the LLVM IR. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_TRANSFORMS_IPO_H
#define LLVM_C_TRANSFORMS_IPO_H

21
include/llvm-c/Transforms/PassManagerBuilder.h
Просмотреть файл

@ -1,14 +1,15 @@
/*===-- llvm-c/Transform/PassManagerBuilder.h - PMB C Interface ---*- C -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// PassManagerBuilder.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to the PassManagerBuilder class. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header declares the C interface to the PassManagerBuilder class. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_TRANSFORMS_PASSMANAGERBUILDER_H
#define LLVM_C_TRANSFORMS_PASSMANAGERBUILDER_H

30
include/llvm-c/Transforms/Scalar.h
Просмотреть файл

@ -1,18 +1,20 @@
/*===-- Scalar.h - Scalar Transformation Library C Interface ----*- C++ -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// Scalar.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to libLLVMScalarOpts.a, which //
// implements various scalar transformations of the LLVM IR. //
// Many exotic languages can interoperate with C code but have a harder time //
// with C++ due to name mangling. So in addition to C, this interface enables//
// tools written in such languages. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header declares the C interface to libLLVMScalarOpts.a, which *|
|* implements various scalar transformations of the LLVM IR. *|
|* *|
|* Many exotic languages can interoperate with C code but have a harder time *|
|* with C++ due to name mangling. So in addition to C, this interface enables *|
|* tools written in such languages. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_TRANSFORMS_SCALAR_H
#define LLVM_C_TRANSFORMS_SCALAR_H

31
include/llvm-c/Transforms/Vectorize.h
Просмотреть файл

@ -1,18 +1,21 @@
/*===---------------------------Vectorize.h --------------------- -*- C -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// Vectorize.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header declares the C interface to libLLVMVectorize.a, which //
// implements various vectorization transformations of the LLVM IR. //
// Many exotic languages can interoperate with C code but have a harder time //
// with C++ due to name mangling. So in addition to C, this interface enables//
// tools written in such languages. //
// //
///////////////////////////////////////////////////////////////////////////////
|*===----------- Vectorization Transformation Library C Interface ---------===*|
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header declares the C interface to libLLVMVectorize.a, which *|
|* implements various vectorization transformations of the LLVM IR. *|
|* *|
|* Many exotic languages can interoperate with C code but have a harder time *|
|* with C++ due to name mangling. So in addition to C, this interface enables *|
|* tools written in such languages. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_TRANSFORMS_VECTORIZE_H
#define LLVM_C_TRANSFORMS_VECTORIZE_H

25
include/llvm-c/lto.h
Просмотреть файл

@ -1,16 +1,17 @@
/*===-- llvm-c/lto.h - LTO Public C Interface ---------------------*- C -*-===*\
///////////////////////////////////////////////////////////////////////////////
// //
// lto.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This header provides public interface to an abstract link time optimization//
// library. LLVM provides an implementation of this interface for use with //
// llvm bitcode files. //
// //
///////////////////////////////////////////////////////////////////////////////
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header provides public interface to an abstract link time optimization*|
|* library. LLVM provides an implementation of this interface for use with *|
|* llvm bitcode files. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_LTO_H
#define LLVM_C_LTO_H

25
include/llvm/ADT/APFloat.h
Просмотреть файл

@ -1,19 +1,18 @@
//===- llvm/ADT/APFloat.h - Arbitrary Precision Floating Point ---*- C++ -*-==//
///////////////////////////////////////////////////////////////////////////////
// //
// APFloat.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file //
/// \brief //
/// This file declares a class to represent arbitrary precision floating point//
/// values and provide a variety of arithmetic operations on them. //
/// \file
/// \brief
/// This file declares a class to represent arbitrary precision floating point
/// values and provide a variety of arithmetic operations on them.
///
// //
///////////////////////////////////////////////////////////////////////////////
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_APFLOAT_H
#define LLVM_ADT_APFLOAT_H

20
include/llvm/ADT/APInt.h
Просмотреть файл

@ -1,15 +1,15 @@
//===-- llvm/ADT/APInt.h - For Arbitrary Precision Integer -----*- C++ -*--===//
///////////////////////////////////////////////////////////////////////////////
// //
// APInt.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file //
/// \brief This file implements a class to represent arbitrary precision //
/// integral constant values and operations on them. //
/// \file
/// \brief This file implements a class to represent arbitrary precision
/// integral constant values and operations on them.
///
//===----------------------------------------------------------------------===//

21
include/llvm/ADT/APSInt.h
Просмотреть файл

@ -1,15 +1,16 @@
//===-- llvm/ADT/APSInt.h - Arbitrary Precision Signed Int -----*- C++ -*--===//
///////////////////////////////////////////////////////////////////////////////
// //
// APSInt.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements the APSInt class, which is a simple class that //
// represents an arbitrary sized integer that knows its signedness. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the APSInt class, which is a simple class that
// represents an arbitrary sized integer that knows its signedness.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_APSINT_H
#define LLVM_ADT_APSINT_H

15
include/llvm/ADT/ArrayRef.h
Просмотреть файл

@ -1,12 +1,11 @@
//===--- ArrayRef.h - Array Reference Wrapper -------------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// ArrayRef.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
///////////////////////////////////////////////////////////////////////////////
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_ARRAYREF_H
#define LLVM_ADT_ARRAYREF_H

19
include/llvm/ADT/BitVector.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- llvm/ADT/BitVector.h - Bit vectors -----------------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// BitVector.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements the BitVector class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the BitVector class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_BITVECTOR_H
#define LLVM_ADT_BITVECTOR_H

14
include/llvm/ADT/DAGDeltaAlgorithm.h
Просмотреть файл

@ -1,12 +1,10 @@
//===--- DAGDeltaAlgorithm.h - A DAG Minimization Algorithm ----*- C++ -*--===//
///////////////////////////////////////////////////////////////////////////////
// //
// DAGDeltaAlgorithm.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
///////////////////////////////////////////////////////////////////////////////
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_DAGDELTAALGORITHM_H
#define LLVM_ADT_DAGDELTAALGORITHM_H

14
include/llvm/ADT/DeltaAlgorithm.h
Просмотреть файл

@ -1,12 +1,10 @@
//===--- DeltaAlgorithm.h - A Set Minimization Algorithm -------*- C++ -*--===//
///////////////////////////////////////////////////////////////////////////////
// //
// DeltaAlgorithm.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
///////////////////////////////////////////////////////////////////////////////
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_DELTAALGORITHM_H
#define LLVM_ADT_DELTAALGORITHM_H

19
include/llvm/ADT/DenseMap.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- llvm/ADT/DenseMap.h - Dense probed hash table ------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// DenseMap.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the DenseMap class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the DenseMap class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_DENSEMAP_H
#define LLVM_ADT_DENSEMAP_H

19
include/llvm/ADT/DenseMapInfo.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- llvm/ADT/DenseMapInfo.h - Type traits for DenseMap -------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// DenseMapInfo.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines DenseMapInfo traits for DenseMap. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines DenseMapInfo traits for DenseMap.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_DENSEMAPINFO_H
#define LLVM_ADT_DENSEMAPINFO_H

19
include/llvm/ADT/DenseSet.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- llvm/ADT/DenseSet.h - Dense probed hash table ------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// DenseSet.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the DenseSet class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the DenseSet class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_DENSESET_H
#define LLVM_ADT_DENSESET_H

49
include/llvm/ADT/DepthFirstIterator.h
Просмотреть файл

@ -1,33 +1,34 @@
//===- llvm/ADT/DepthFirstIterator.h - Depth First iterator -----*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// DepthFirstIterator.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file builds on the ADT/GraphTraits.h file to build generic depth //
// first graph iterator. This file exposes the following functions/types: //
//
// df_begin/df_end/df_iterator //
// * Normal depth-first iteration - visit a node and then all of its children.//
// The LLVM Compiler Infrastructure
//
// idf_begin/idf_end/idf_iterator //
// * Depth-first iteration on the 'inverse' graph. //
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
// df_ext_begin/df_ext_end/df_ext_iterator //
// * Normal depth-first iteration - visit a node and then all of its children.//
// This iterator stores the 'visited' set in an external set, which allows//
// it to be more efficient, and allows external clients to use the set for//
// other purposes. //
//===----------------------------------------------------------------------===//
//
// idf_ext_begin/idf_ext_end/idf_ext_iterator //
// * Depth-first iteration on the 'inverse' graph. //
// This iterator stores the 'visited' set in an external set, which allows//
// it to be more efficient, and allows external clients to use the set for//
// other purposes. //
// This file builds on the ADT/GraphTraits.h file to build generic depth
// first graph iterator. This file exposes the following functions/types:
//
///////////////////////////////////////////////////////////////////////////////
// df_begin/df_end/df_iterator
// * Normal depth-first iteration - visit a node and then all of its children.
//
// idf_begin/idf_end/idf_iterator
// * Depth-first iteration on the 'inverse' graph.
//
// df_ext_begin/df_ext_end/df_ext_iterator
// * Normal depth-first iteration - visit a node and then all of its children.
// This iterator stores the 'visited' set in an external set, which allows
// it to be more efficient, and allows external clients to use the set for
// other purposes.
//
// idf_ext_begin/idf_ext_end/idf_ext_iterator
// * Depth-first iteration on the 'inverse' graph.
// This iterator stores the 'visited' set in an external set, which allows
// it to be more efficient, and allows external clients to use the set for
// other purposes.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_DEPTHFIRSTITERATOR_H
#define LLVM_ADT_DEPTHFIRSTITERATOR_H

23
include/llvm/ADT/EpochTracker.h
Просмотреть файл

@ -1,16 +1,17 @@
//===- llvm/ADT/EpochTracker.h - ADT epoch tracking --------------*- C++ -*-==//
///////////////////////////////////////////////////////////////////////////////
// //
// EpochTracker.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the DebugEpochBase and DebugEpochBase::HandleBase classes.//
// These can be used to write iterators that are fail-fast when LLVM is built//
// with asserts enabled. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the DebugEpochBase and DebugEpochBase::HandleBase classes.
// These can be used to write iterators that are fail-fast when LLVM is built
// with asserts enabled.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_EPOCH_TRACKER_H
#define LLVM_ADT_EPOCH_TRACKER_H

21
include/llvm/ADT/EquivalenceClasses.h
Просмотреть файл

@ -1,15 +1,16 @@
//===-- llvm/ADT/EquivalenceClasses.h - Generic Equiv. Classes --*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// EquivalenceClasses.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// Generic implementation of equivalence classes through the use Tarjan's //
// efficient union-find algorithm. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Generic implementation of equivalence classes through the use Tarjan's
// efficient union-find algorithm.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_EQUIVALENCECLASSES_H
#define LLVM_ADT_EQUIVALENCECLASSES_H

21
include/llvm/ADT/FoldingSet.h
Просмотреть файл

@ -1,14 +1,15 @@
//===-- llvm/ADT/FoldingSet.h - Uniquing Hash Set ---------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// FoldingSet.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines a hash set that can be used to remove duplication of nodes//
// in a graph. This code was originally created by Chris Lattner for use with//
// SelectionDAGCSEMap, but was isolated to provide use across the llvm code set.//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines a hash set that can be used to remove duplication of nodes
// in a graph. This code was originally created by Chris Lattner for use with
// SelectionDAGCSEMap, but was isolated to provide use across the llvm code set.
//
//===----------------------------------------------------------------------===//

25
include/llvm/ADT/GraphTraits.h
Просмотреть файл

@ -1,18 +1,19 @@
//===-- llvm/ADT/GraphTraits.h - Graph traits template ----------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// GraphTraits.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the little GraphTraits<X> template class that should be //
// specialized by classes that want to be iteratable by generic graph iterators.//
//
// This file also defines the marker class Inverse that is used to iterate over//
// graphs in a graph defined, inverse ordering... //
// The LLVM Compiler Infrastructure
//
///////////////////////////////////////////////////////////////////////////////
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the little GraphTraits<X> template class that should be
// specialized by classes that want to be iteratable by generic graph iterators.
//
// This file also defines the marker class Inverse that is used to iterate over
// graphs in a graph defined, inverse ordering...
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_GRAPHTRAITS_H
#define LLVM_ADT_GRAPHTRAITS_H

71
include/llvm/ADT/Hashing.h
Просмотреть файл

@ -1,45 +1,46 @@
//===-- llvm/ADT/Hashing.h - Utilities for hashing --------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// Hashing.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements the newly proposed standard C++ interfaces for hashing//
// arbitrary data and building hash functions for user-defined types. This //
// interface was originally proposed in N3333[1] and is currently under review//
// for inclusion in a future TR and/or standard. //
//
// The primary interfaces provide are comprised of one type and three functions://
// The LLVM Compiler Infrastructure
//
// -- 'hash_code' class is an opaque type representing the hash code for some//
// data. It is the intended product of hashing, and can be used to implement//
// hash tables, checksumming, and other common uses of hashes. It is not an//
// integer type (although it can be converted to one) because it is risky//
// to assume much about the internals of a hash_code. In particular, each//
// execution of the program has a high probability of producing a different//
// hash_code for a given input. Thus their values are not stable to save or//
// persist, and should only be used during the execution for the //
// construction of hashing datastructures. //
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
// -- 'hash_value' is a function designed to be overloaded for each //
// user-defined type which wishes to be used within a hashing context. It//
// should be overloaded within the user-defined type's namespace and found//
// via ADL. Overloads for primitive types are provided by this library. //
//===----------------------------------------------------------------------===//
//
// -- 'hash_combine' and 'hash_combine_range' are functions designed to aid //
// programmers in easily and intuitively combining a set of data into //
// a single hash_code for their object. They should only logically be used//
// within the implementation of a 'hash_value' routine or similar context.//
// This file implements the newly proposed standard C++ interfaces for hashing
// arbitrary data and building hash functions for user-defined types. This
// interface was originally proposed in N3333[1] and is currently under review
// for inclusion in a future TR and/or standard.
//
// Note that 'hash_combine_range' contains very special logic for hashing //
// a contiguous array of integers or pointers. This logic is *extremely* fast,//
// on a modern Intel "Gainestown" Xeon (Nehalem uarch) @2.2 GHz, these were //
// benchmarked at over 6.5 GiB/s for large keys, and <20 cycles/hash for keys//
// under 32-bytes. //
// The primary interfaces provide are comprised of one type and three functions:
//
///////////////////////////////////////////////////////////////////////////////
// -- 'hash_code' class is an opaque type representing the hash code for some
// data. It is the intended product of hashing, and can be used to implement
// hash tables, checksumming, and other common uses of hashes. It is not an
// integer type (although it can be converted to one) because it is risky
// to assume much about the internals of a hash_code. In particular, each
// execution of the program has a high probability of producing a different
// hash_code for a given input. Thus their values are not stable to save or
// persist, and should only be used during the execution for the
// construction of hashing datastructures.
//
// -- 'hash_value' is a function designed to be overloaded for each
// user-defined type which wishes to be used within a hashing context. It
// should be overloaded within the user-defined type's namespace and found
// via ADL. Overloads for primitive types are provided by this library.
//
// -- 'hash_combine' and 'hash_combine_range' are functions designed to aid
// programmers in easily and intuitively combining a set of data into
// a single hash_code for their object. They should only logically be used
// within the implementation of a 'hash_value' routine or similar context.
//
// Note that 'hash_combine_range' contains very special logic for hashing
// a contiguous array of integers or pointers. This logic is *extremely* fast,
// on a modern Intel "Gainestown" Xeon (Nehalem uarch) @2.2 GHz, these were
// benchmarked at over 6.5 GiB/s for large keys, and <20 cycles/hash for keys
// under 32-bytes.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_HASHING_H
#define LLVM_ADT_HASHING_H

17
include/llvm/ADT/ImmutableList.h
Просмотреть файл

@ -1,12 +1,13 @@
//==--- ImmutableList.h - Immutable (functional) list interface --*- C++ -*-==//
///////////////////////////////////////////////////////////////////////////////
// //
// ImmutableList.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the ImmutableList class. //
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the ImmutableList class.
//
//===----------------------------------------------------------------------===//

19
include/llvm/ADT/ImmutableMap.h
Просмотреть файл

@ -1,14 +1,15 @@
//===--- ImmutableMap.h - Immutable (functional) map interface --*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// ImmutableMap.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the ImmutableMap class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the ImmutableMap class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_IMMUTABLEMAP_H
#define LLVM_ADT_IMMUTABLEMAP_H

17
include/llvm/ADT/ImmutableSet.h
Просмотреть файл

@ -1,12 +1,13 @@
//===--- ImmutableSet.h - Immutable (functional) set interface --*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// ImmutableSet.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the ImutAVLTree and ImmutableSet classes. //
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the ImutAVLTree and ImmutableSet classes.
//
//===----------------------------------------------------------------------===//

31
include/llvm/ADT/IndexedMap.h
Просмотреть файл

@ -1,20 +1,21 @@
//===- llvm/ADT/IndexedMap.h - An index map implementation ------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// IndexedMap.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements an indexed map. The index map template takes two //
// types. The first is the mapped type and the second is a functor //
// that maps its argument to a size_t. On instantiation a "null" value //
// can be provided to be used as a "does not exist" indicator in the //
// map. A member function grow() is provided that given the value of //
// the maximally indexed key (the argument of the functor) makes sure //
// the map has enough space for it. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements an indexed map. The index map template takes two
// types. The first is the mapped type and the second is a functor
// that maps its argument to a size_t. On instantiation a "null" value
// can be provided to be used as a "does not exist" indicator in the
// map. A member function grow() is provided that given the value of
// the maximally indexed key (the argument of the functor) makes sure
// the map has enough space for it.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_INDEXEDMAP_H
#define LLVM_ADT_INDEXEDMAP_H

29
include/llvm/ADT/IntEqClasses.h
Просмотреть файл

@ -1,21 +1,22 @@
//===-- llvm/ADT/IntEqClasses.h - Equiv. Classes of Integers ----*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// IntEqClasses.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// Equivalence classes for small integers. This is a mapping of the integers //
// 0 .. N-1 into M equivalence classes numbered 0 .. M-1. //
//
// Initially each integer has its own equivalence class. Classes are joined by//
// passing a representative member of each class to join(). //
// The LLVM Compiler Infrastructure
//
// Once the classes are built, compress() will number them 0 .. M-1 and prevent//
// further changes. //
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
///////////////////////////////////////////////////////////////////////////////
//===----------------------------------------------------------------------===//
//
// Equivalence classes for small integers. This is a mapping of the integers
// 0 .. N-1 into M equivalence classes numbered 0 .. M-1.
//
// Initially each integer has its own equivalence class. Classes are joined by
// passing a representative member of each class to join().
//
// Once the classes are built, compress() will number them 0 .. M-1 and prevent
// further changes.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_INTEQCLASSES_H
#define LLVM_ADT_INTEQCLASSES_H

159
include/llvm/ADT/IntervalMap.h
Просмотреть файл

@ -1,97 +1,98 @@
//===- llvm/ADT/IntervalMap.h - A sorted interval map -----------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// IntervalMap.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements a coalescing interval map for small objects. //
//
// KeyT objects are mapped to ValT objects. Intervals of keys that map to the//
// same value are represented in a compressed form. //
// The LLVM Compiler Infrastructure
//
// Iterators provide ordered access to the compressed intervals rather than the//
// individual keys, and insert and erase operations use key intervals as well.//
//
// Like SmallVector, IntervalMap will store the first N intervals in the map //
// object itself without any allocations. When space is exhausted it switches to//
// a B+-tree representation with very small overhead for small key and value //
// objects. //
//
// A Traits class specifies how keys are compared. It also allows IntervalMap to//
// work with both closed and half-open intervals. //
//
// Keys and values are not stored next to each other in a std::pair, so we don't//
// provide such a value_type. Dereferencing iterators only returns the mapped//
// value. The interval bounds are accessible through the start() and stop() //
// iterator methods. //
//
// IntervalMap is optimized for small key and value objects, 4 or 8 bytes each//
// is the optimal size. For large objects use std::map instead. //
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Synopsis: //
// This file implements a coalescing interval map for small objects.
//
// template <typename KeyT, typename ValT, unsigned N, typename Traits> //
// class IntervalMap { //
// public: //
// typedef KeyT key_type; //
// typedef ValT mapped_type; //
// typedef RecyclingAllocator<...> Allocator; //
// class iterator; //
// class const_iterator; //
// KeyT objects are mapped to ValT objects. Intervals of keys that map to the
// same value are represented in a compressed form.
//
// explicit IntervalMap(Allocator&); //
// ~IntervalMap(): //
// Iterators provide ordered access to the compressed intervals rather than the
// individual keys, and insert and erase operations use key intervals as well.
//
// bool empty() const; //
// KeyT start() const; //
// KeyT stop() const; //
// ValT lookup(KeyT x, Value NotFound = Value()) const; //
// Like SmallVector, IntervalMap will store the first N intervals in the map
// object itself without any allocations. When space is exhausted it switches to
// a B+-tree representation with very small overhead for small key and value
// objects.
//
// const_iterator begin() const; //
// const_iterator end() const; //
// iterator begin(); //
// iterator end(); //
// const_iterator find(KeyT x) const; //
// iterator find(KeyT x); //
// A Traits class specifies how keys are compared. It also allows IntervalMap to
// work with both closed and half-open intervals.
//
// void insert(KeyT a, KeyT b, ValT y); //
// void clear(); //
// }; //
// Keys and values are not stored next to each other in a std::pair, so we don't
// provide such a value_type. Dereferencing iterators only returns the mapped
// value. The interval bounds are accessible through the start() and stop()
// iterator methods.
//
// template <typename KeyT, typename ValT, unsigned N, typename Traits> //
// class IntervalMap::const_iterator : //
// public std::iterator<std::bidirectional_iterator_tag, ValT> { //
// public: //
// bool operator==(const const_iterator &) const; //
// bool operator!=(const const_iterator &) const; //
// bool valid() const; //
// IntervalMap is optimized for small key and value objects, 4 or 8 bytes each
// is the optimal size. For large objects use std::map instead.
//
// const KeyT &start() const; //
// const KeyT &stop() const; //
// const ValT &value() const; //
// const ValT &operator*() const; //
// const ValT *operator->() const; //
//===----------------------------------------------------------------------===//
//
// const_iterator &operator++(); //
// const_iterator &operator++(int); //
// const_iterator &operator--(); //
// const_iterator &operator--(int); //
// void goToBegin(); //
// void goToEnd(); //
// void find(KeyT x); //
// void advanceTo(KeyT x); //
// }; //
// Synopsis:
//
// template <typename KeyT, typename ValT, unsigned N, typename Traits> //
// class IntervalMap::iterator : public const_iterator { //
// public: //
// void insert(KeyT a, KeyT b, Value y); //
// void erase(); //
// }; //
// template <typename KeyT, typename ValT, unsigned N, typename Traits>
// class IntervalMap {
// public:
// typedef KeyT key_type;
// typedef ValT mapped_type;
// typedef RecyclingAllocator<...> Allocator;
// class iterator;
// class const_iterator;
//
// explicit IntervalMap(Allocator&);
// ~IntervalMap():
//
// bool empty() const;
// KeyT start() const;
// KeyT stop() const;
// ValT lookup(KeyT x, Value NotFound = Value()) const;
//
// const_iterator begin() const;
// const_iterator end() const;
// iterator begin();
// iterator end();
// const_iterator find(KeyT x) const;
// iterator find(KeyT x);
//
// void insert(KeyT a, KeyT b, ValT y);
// void clear();
// };
//
// template <typename KeyT, typename ValT, unsigned N, typename Traits>
// class IntervalMap::const_iterator :
// public std::iterator<std::bidirectional_iterator_tag, ValT> {
// public:
// bool operator==(const const_iterator &) const;
// bool operator!=(const const_iterator &) const;
// bool valid() const;
//
// const KeyT &start() const;
// const KeyT &stop() const;
// const ValT &value() const;
// const ValT &operator*() const;
// const ValT *operator->() const;
//
// const_iterator &operator++();
// const_iterator &operator++(int);
// const_iterator &operator--();
// const_iterator &operator--(int);
// void goToBegin();
// void goToEnd();
// void find(KeyT x);
// void advanceTo(KeyT x);
// };
//
// template <typename KeyT, typename ValT, unsigned N, typename Traits>
// class IntervalMap::iterator : public const_iterator {
// public:
// void insert(KeyT a, KeyT b, Value y);
// void erase();
// };
//
//===----------------------------------------------------------------------===//

29
include/llvm/ADT/IntrusiveRefCntPtr.h
Просмотреть файл

@ -1,19 +1,20 @@
//== llvm/ADT/IntrusiveRefCntPtr.h - Smart Refcounting Pointer ---*- C++ -*-==//
///////////////////////////////////////////////////////////////////////////////
// //
// IntrusiveRefCntPtr.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines IntrusiveRefCntPtr, a template class that //
// implements a "smart" pointer for objects that maintain their own //
// internal reference count, and RefCountedBase/RefCountedBaseVPTR, two //
// generic base classes for objects that wish to have their lifetimes //
// managed using reference counting. //
//
// IntrusiveRefCntPtr is similar to Boost's intrusive_ptr with added //
// LLVM-style casting. //
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines IntrusiveRefCntPtr, a template class that
// implements a "smart" pointer for objects that maintain their own
// internal reference count, and RefCountedBase/RefCountedBaseVPTR, two
// generic base classes for objects that wish to have their lifetimes
// managed using reference counting.
//
// IntrusiveRefCntPtr is similar to Boost's intrusive_ptr with added
// LLVM-style casting.
//
//===----------------------------------------------------------------------===//

25
include/llvm/ADT/MapVector.h
Просмотреть файл

@ -1,17 +1,18 @@
//===- llvm/ADT/MapVector.h - Map w/ deterministic value order --*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// MapVector.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements a map that provides insertion order iteration. The //
// interface is purposefully minimal. The key is assumed to be cheap to copy //
// and 2 copies are kept, one for indexing in a DenseMap, one for iteration in//
// a std::vector. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements a map that provides insertion order iteration. The
// interface is purposefully minimal. The key is assumed to be cheap to copy
// and 2 copies are kept, one for indexing in a DenseMap, one for iteration in
// a std::vector.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_MAPVECTOR_H
#define LLVM_ADT_MAPVECTOR_H

23
include/llvm/ADT/None.h
Просмотреть файл

@ -1,16 +1,17 @@
//===-- None.h - Simple null value for implicit construction ------*- C++ -*-=//
///////////////////////////////////////////////////////////////////////////////
// //
// None.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file provides None, an enumerator for use in implicit constructors //
// of various (usually templated) types to make such construction more //
// terse. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file provides None, an enumerator for use in implicit constructors
// of various (usually templated) types to make such construction more
// terse.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_NONE_H
#define LLVM_ADT_NONE_H

23
include/llvm/ADT/Optional.h
Просмотреть файл

@ -1,16 +1,17 @@
//===-- Optional.h - Simple variant for passing optional values ---*- C++ -*-=//
///////////////////////////////////////////////////////////////////////////////
// //
// Optional.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file provides Optional, a template class modeled in the spirit of //
// OCaml's 'opt' variant. The idea is to strongly type whether or not //
// a value can be optional. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file provides Optional, a template class modeled in the spirit of
// OCaml's 'opt' variant. The idea is to strongly type whether or not
// a value can be optional.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_OPTIONAL_H
#define LLVM_ADT_OPTIONAL_H

19
include/llvm/ADT/PackedVector.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- llvm/ADT/PackedVector.h - Packed values vector -----------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// PackedVector.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements the PackedVector class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the PackedVector class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_PACKEDVECTOR_H
#define LLVM_ADT_PACKEDVECTOR_H

19
include/llvm/ADT/PointerIntPair.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- llvm/ADT/PointerIntPair.h - Pair for pointer and int -----*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// PointerIntPair.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the PointerIntPair class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the PointerIntPair class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_POINTERINTPAIR_H
#define LLVM_ADT_POINTERINTPAIR_H

21
include/llvm/ADT/PointerUnion.h
Просмотреть файл

@ -1,15 +1,16 @@
//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// PointerUnion.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the PointerUnion class, which is a discriminated union of//
// pointer types. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the PointerUnion class, which is a discriminated union of
// pointer types.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_POINTERUNION_H
#define LLVM_ADT_POINTERUNION_H

23
include/llvm/ADT/PostOrderIterator.h
Просмотреть файл

@ -1,16 +1,17 @@
//===- llvm/ADT/PostOrderIterator.h - PostOrder iterator --------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// PostOrderIterator.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file builds on the ADT/GraphTraits.h file to build a generic graph //
// post order iterator. This should work over any graph type that has a //
// GraphTraits specialization. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file builds on the ADT/GraphTraits.h file to build a generic graph
// post order iterator. This should work over any graph type that has a
// GraphTraits specialization.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_POSTORDERITERATOR_H
#define LLVM_ADT_POSTORDERITERATOR_H

19
include/llvm/ADT/PriorityQueue.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- llvm/ADT/PriorityQueue.h - Priority queues ---------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// PriorityQueue.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the PriorityQueue class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the PriorityQueue class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_PRIORITYQUEUE_H
#define LLVM_ADT_PRIORITYQUEUE_H

33
include/llvm/ADT/SCCIterator.h
Просмотреть файл

@ -1,25 +1,24 @@
//===---- ADT/SCCIterator.h - Strongly Connected Comp. Iter. ----*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// SCCIterator.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
/// \file //
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
/// \file
///
/// This builds on the llvm/ADT/GraphTraits.h file to find the strongly //
/// connected components (SCCs) of a graph in O(N+E) time using Tarjan's DFS //
/// algorithm. //
/// This builds on the llvm/ADT/GraphTraits.h file to find the strongly
/// connected components (SCCs) of a graph in O(N+E) time using Tarjan's DFS
/// algorithm.
///
/// The SCC iterator has the important property that if a node in SCC S1 has an//
/// edge to a node in SCC S2, then it visits S1 *after* S2. //
/// The SCC iterator has the important property that if a node in SCC S1 has an
/// edge to a node in SCC S2, then it visits S1 *after* S2.
///
/// To visit S1 *before* S2, use the scc_iterator on the Inverse graph. (NOTE://
/// This requires some simple wrappers and is not supported yet.) //
/// To visit S1 *before* S2, use the scc_iterator on the Inverse graph. (NOTE:
/// This requires some simple wrappers and is not supported yet.)
///
// //
///////////////////////////////////////////////////////////////////////////////
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SCCITERATOR_H
#define LLVM_ADT_SCCITERATOR_H

21
include/llvm/ADT/STLExtras.h
Просмотреть файл

@ -1,15 +1,16 @@
//===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// STLExtras.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file contains some templates that are useful if you are working with the//
// STL at all. //
//
// No library is required when using these functions. //
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains some templates that are useful if you are working with the
// STL at all.
//
// No library is required when using these functions.
//
//===----------------------------------------------------------------------===//

49
include/llvm/ADT/ScopedHashTable.h
Просмотреть файл

@ -1,31 +1,32 @@
//===- ScopedHashTable.h - A simple scoped hash table ---------------------===//
///////////////////////////////////////////////////////////////////////////////
// //
// ScopedHashTable.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements an efficient scoped hash table, which is useful for //
// things like dominator-based optimizations. This allows clients to do things//
// like this: //
//
// ScopedHashTable<int, int> HT; //
// { //
// ScopedHashTableScope<int, int> Scope1(HT); //
// HT.insert(0, 0); //
// HT.insert(1, 1); //
// { //
// ScopedHashTableScope<int, int> Scope2(HT); //
// HT.insert(0, 42); //
// } //
// } //
// The LLVM Compiler Infrastructure
//
// Looking up the value for "0" in the Scope2 block will return 42. Looking //
// up the value for 0 before 42 is inserted or after Scope2 is popped will //
// return 0. //
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
///////////////////////////////////////////////////////////////////////////////
//===----------------------------------------------------------------------===//
//
// This file implements an efficient scoped hash table, which is useful for
// things like dominator-based optimizations. This allows clients to do things
// like this:
//
// ScopedHashTable<int, int> HT;
// {
// ScopedHashTableScope<int, int> Scope1(HT);
// HT.insert(0, 0);
// HT.insert(1, 1);
// {
// ScopedHashTableScope<int, int> Scope2(HT);
// HT.insert(0, 42);
// }
// }
//
// Looking up the value for "0" in the Scope2 block will return 42. Looking
// up the value for 0 before 42 is inserted or after Scope2 is popped will
// return 0.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SCOPEDHASHTABLE_H
#define LLVM_ADT_SCOPEDHASHTABLE_H

21
include/llvm/ADT/SetOperations.h
Просмотреть файл

@ -1,15 +1,16 @@
//===-- llvm/ADT/SetOperations.h - Generic Set Operations -------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// SetOperations.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines generic set operations that may be used on set's of //
// different types, and different element types. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines generic set operations that may be used on set's of
// different types, and different element types.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SETOPERATIONS_H
#define LLVM_ADT_SETOPERATIONS_H

29
include/llvm/ADT/SetVector.h
Просмотреть файл

@ -1,20 +1,21 @@
//===- llvm/ADT/SetVector.h - Set with insert order iteration ---*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// SetVector.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements a set that has insertion order iteration //
// characteristics. This is useful for keeping a set of things that need to be//
// visited later but in a deterministic order (insertion order). The interface//
// is purposefully minimal. //
//
// This file defines SetVector and SmallSetVector, which performs no allocations//
// if the SetVector has less than a certain number of elements. //
// The LLVM Compiler Infrastructure
//
///////////////////////////////////////////////////////////////////////////////
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements a set that has insertion order iteration
// characteristics. This is useful for keeping a set of things that need to be
// visited later but in a deterministic order (insertion order). The interface
// is purposefully minimal.
//
// This file defines SetVector and SmallSetVector, which performs no allocations
// if the SetVector has less than a certain number of elements.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SETVECTOR_H
#define LLVM_ADT_SETVECTOR_H

19
include/llvm/ADT/SmallBitVector.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- llvm/ADT/SmallBitVector.h - 'Normally small' bit vectors -*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// SmallBitVector.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements the SmallBitVector class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the SmallBitVector class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SMALLBITVECTOR_H
#define LLVM_ADT_SMALLBITVECTOR_H

21
include/llvm/ADT/SmallPtrSet.h
Просмотреть файл

@ -1,15 +1,16 @@
//===- llvm/ADT/SmallPtrSet.h - 'Normally small' pointer set ----*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// SmallPtrSet.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the SmallPtrSet class. See the doxygen comment for //
// SmallPtrSetImplBase for more details on the algorithm used. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the SmallPtrSet class. See the doxygen comment for
// SmallPtrSetImplBase for more details on the algorithm used.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SMALLPTRSET_H
#define LLVM_ADT_SMALLPTRSET_H

19
include/llvm/ADT/SmallSet.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- llvm/ADT/SmallSet.h - 'Normally small' sets --------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// SmallSet.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the SmallSet class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the SmallSet class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SMALLSET_H
#define LLVM_ADT_SMALLSET_H

19
include/llvm/ADT/SmallString.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- llvm/ADT/SmallString.h - 'Normally small' strings --------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// SmallString.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the SmallString class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the SmallString class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SMALLSTRING_H
#define LLVM_ADT_SMALLSTRING_H

19
include/llvm/ADT/SmallVector.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- llvm/ADT/SmallVector.h - 'Normally small' vectors --------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// SmallVector.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the SmallVector class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the SmallVector class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SMALLVECTOR_H
#define LLVM_ADT_SMALLVECTOR_H

21
include/llvm/ADT/SparseBitVector.h
Просмотреть файл

@ -1,15 +1,16 @@
//===- llvm/ADT/SparseBitVector.h - Efficient Sparse BitVector -*- C++ -*- ===//
///////////////////////////////////////////////////////////////////////////////
// //
// SparseBitVector.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the SparseBitVector class. See the doxygen comment for //
// SparseBitVector for more details on the algorithm used. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the SparseBitVector class. See the doxygen comment for
// SparseBitVector for more details on the algorithm used.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SPARSEBITVECTOR_H
#define LLVM_ADT_SPARSEBITVECTOR_H

31
include/llvm/ADT/SparseMultiSet.h
Просмотреть файл

@ -1,21 +1,22 @@
//===--- llvm/ADT/SparseMultiSet.h - Sparse multiset ------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// SparseMultiSet.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the SparseMultiSet class, which adds multiset behavior to//
// the SparseSet. //
//
// A sparse multiset holds a small number of objects identified by integer keys//
// from a moderately sized universe. The sparse multiset uses more memory than//
// other containers in order to provide faster operations. Any key can map to//
// multiple values. A SparseMultiSetNode class is provided, which serves as a//
// convenient base class for the contents of a SparseMultiSet. //
// The LLVM Compiler Infrastructure
//
///////////////////////////////////////////////////////////////////////////////
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the SparseMultiSet class, which adds multiset behavior to
// the SparseSet.
//
// A sparse multiset holds a small number of objects identified by integer keys
// from a moderately sized universe. The sparse multiset uses more memory than
// other containers in order to provide faster operations. Any key can map to
// multiple values. A SparseMultiSetNode class is provided, which serves as a
// convenient base class for the contents of a SparseMultiSet.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SPARSEMULTISET_H
#define LLVM_ADT_SPARSEMULTISET_H

29
include/llvm/ADT/SparseSet.h
Просмотреть файл

@ -1,20 +1,21 @@
//===--- llvm/ADT/SparseSet.h - Sparse set ----------------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// SparseSet.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the SparseSet class derived from the version described in//
// Briggs, Torczon, "An efficient representation for sparse sets", ACM Letters//
// on Programming Languages and Systems, Volume 2 Issue 1-4, March-Dec. 1993.//
//
// A sparse set holds a small number of objects identified by integer keys from//
// a moderately sized universe. The sparse set uses more memory than other //
// containers in order to provide faster operations. //
// The LLVM Compiler Infrastructure
//
///////////////////////////////////////////////////////////////////////////////
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the SparseSet class derived from the version described in
// Briggs, Torczon, "An efficient representation for sparse sets", ACM Letters
// on Programming Languages and Systems, Volume 2 Issue 1-4, March-Dec. 1993.
//
// A sparse set holds a small number of objects identified by integer keys from
// a moderately sized universe. The sparse set uses more memory than other
// containers in order to provide faster operations.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_SPARSESET_H
#define LLVM_ADT_SPARSESET_H

35
include/llvm/ADT/Statistic.h
Просмотреть файл

@ -1,26 +1,27 @@
//===-- llvm/ADT/Statistic.h - Easy way to expose stats ---------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// Statistic.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the 'Statistic' class, which is designed to be an easy way//
// to expose various metrics from passes. These statistics are printed at the//
// end of a run (from llvm_shutdown), when the -stats command line option is //
// passed on the command line. //
//
// This is useful for reporting information like the number of instructions //
// simplified, optimized or removed by various transformations, like this: //
// The LLVM Compiler Infrastructure
//
// static Statistic NumInstsKilled("gcse", "Number of instructions killed"); //
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
// Later, in the code: ++NumInstsKilled; //
//===----------------------------------------------------------------------===//
//
// NOTE: Statistics *must* be declared as global variables. //
// This file defines the 'Statistic' class, which is designed to be an easy way
// to expose various metrics from passes. These statistics are printed at the
// end of a run (from llvm_shutdown), when the -stats command line option is
// passed on the command line.
//
///////////////////////////////////////////////////////////////////////////////
// This is useful for reporting information like the number of instructions
// simplified, optimized or removed by various transformations, like this:
//
// static Statistic NumInstsKilled("gcse", "Number of instructions killed");
//
// Later, in the code: ++NumInstsKilled;
//
// NOTE: Statistics *must* be declared as global variables.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_STATISTIC_H
#define LLVM_ADT_STATISTIC_H

19
include/llvm/ADT/StringExtras.h
Просмотреть файл

@ -1,14 +1,15 @@
//===-- llvm/ADT/StringExtras.h - Useful string functions -------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// StringExtras.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file contains some functions that are useful when dealing with strings.//
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains some functions that are useful when dealing with strings.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_STRINGEXTRAS_H
#define LLVM_ADT_STRINGEXTRAS_H

19
include/llvm/ADT/StringMap.h
Просмотреть файл

@ -1,14 +1,15 @@
//===--- StringMap.h - String Hash table map interface ----------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// StringMap.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the StringMap class. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the StringMap class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_STRINGMAP_H
#define LLVM_ADT_STRINGMAP_H

15
include/llvm/ADT/StringRef.h
Просмотреть файл

@ -1,12 +1,11 @@
//===--- StringRef.h - Constant String Reference Wrapper --------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// StringRef.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
///////////////////////////////////////////////////////////////////////////////
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_STRINGREF_H
#define LLVM_ADT_STRINGREF_H

19
include/llvm/ADT/StringSet.h
Просмотреть файл

@ -1,14 +1,15 @@
//===--- StringSet.h - The LLVM Compiler Driver -----------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// StringSet.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// StringSet - A set-like wrapper for the StringMap. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open
// Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// StringSet - A set-like wrapper for the StringMap.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_STRINGSET_H
#define LLVM_ADT_STRINGSET_H

22
include/llvm/ADT/StringSwitch.h
Просмотреть файл

@ -1,15 +1,15 @@
//===--- StringSwitch.h - Switch-on-literal-string Construct --------------===/
///////////////////////////////////////////////////////////////////////////////
// //
// StringSwitch.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements the StringSwitch template, which mimics a switch() //
// statement whose cases are string literals. //
// //
///////////////////////////////////////////////////////////////////////////////
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//===----------------------------------------------------------------------===/
//
// This file implements the StringSwitch template, which mimics a switch()
// statement whose cases are string literals.
//
//===----------------------------------------------------------------------===/
#ifndef LLVM_ADT_STRINGSWITCH_H
#define LLVM_ADT_STRINGSWITCH_H

15
include/llvm/ADT/TinyPtrVector.h
Просмотреть файл

@ -1,12 +1,11 @@
//===- llvm/ADT/TinyPtrVector.h - 'Normally tiny' vectors -------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// TinyPtrVector.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
///////////////////////////////////////////////////////////////////////////////
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_TINYPTRVECTOR_H
#define LLVM_ADT_TINYPTRVECTOR_H

15
include/llvm/ADT/Triple.h
Просмотреть файл

@ -1,12 +1,11 @@
//===-- llvm/ADT/Triple.h - Target triple helper class ----------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// Triple.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
///////////////////////////////////////////////////////////////////////////////
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_TRIPLE_H
#define LLVM_ADT_TRIPLE_H

15
include/llvm/ADT/Twine.h
Просмотреть файл

@ -1,12 +1,11 @@
//===-- Twine.h - Fast Temporary String Concatenation -----------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// Twine.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
///////////////////////////////////////////////////////////////////////////////
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_TWINE_H
#define LLVM_ADT_TWINE_H

14
include/llvm/ADT/UniqueVector.h
Просмотреть файл

@ -1,11 +1,11 @@
//===-- llvm/ADT/UniqueVector.h ---------------------------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// UniqueVector.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_UNIQUEVECTOR_H
#define LLVM_ADT_UNIQUEVECTOR_H

19
include/llvm/ADT/VariadicFunction.h
Просмотреть файл

@ -1,14 +1,15 @@
//===--- VariadicFunctions.h - Variadic Functions ---------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// VariadicFunction.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file implements compile-time type-safe variadic functions. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements compile-time type-safe variadic functions.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_VARIADICFUNCTION_H
#define LLVM_ADT_VARIADICFUNCTION_H

23
include/llvm/ADT/edit_distance.h
Просмотреть файл

@ -1,16 +1,17 @@
//===-- llvm/ADT/edit_distance.h - Array edit distance function --- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// edit_distance.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines a Levenshtein distance function that works for any two //
// sequences, with each element of each sequence being analogous to a character//
// in a string. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines a Levenshtein distance function that works for any two
// sequences, with each element of each sequence being analogous to a character
// in a string.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_EDIT_DISTANCE_H
#define LLVM_ADT_EDIT_DISTANCE_H

55
include/llvm/ADT/ilist.h
Просмотреть файл

@ -1,36 +1,37 @@
//==-- llvm/ADT/ilist.h - Intrusive Linked List Template ---------*- C++ -*-==//
///////////////////////////////////////////////////////////////////////////////
// //
// ilist.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines classes to implement an intrusive doubly linked list class//
// (i.e. each node of the list must contain a next and previous field for the//
// list. //
//
// The ilist_traits trait class is used to gain access to the next and previous//
// fields of the node type that the list is instantiated with. If it is not //
// specialized, the list defaults to using the getPrev(), getNext() method calls//
// to get the next and previous pointers. //
// The LLVM Compiler Infrastructure
//
// The ilist class itself, should be a plug in replacement for list, assuming//
// that the nodes contain next/prev pointers. This list replacement does not//
// provide a constant time size() method, so be careful to use empty() when you//
// really want to know if it's empty. //
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
// The ilist class is implemented by allocating a 'tail' node when the list is//
// created (using ilist_traits<>::createSentinel()). This tail node is //
// absolutely required because the user must be able to compute end()-1. Because//
// of this, users of the direct next/prev links will see an extra link on the//
// end of the list, which should be ignored. //
//===----------------------------------------------------------------------===//
//
// Requirements for a user of this list: //
// This file defines classes to implement an intrusive doubly linked list class
// (i.e. each node of the list must contain a next and previous field for the
// list.
//
// 1. The user must provide {g|s}et{Next|Prev} methods, or specialize //
// ilist_traits to provide an alternate way of getting and setting next and//
// prev links. //
// The ilist_traits trait class is used to gain access to the next and previous
// fields of the node type that the list is instantiated with. If it is not
// specialized, the list defaults to using the getPrev(), getNext() method calls
// to get the next and previous pointers.
//
// The ilist class itself, should be a plug in replacement for list, assuming
// that the nodes contain next/prev pointers. This list replacement does not
// provide a constant time size() method, so be careful to use empty() when you
// really want to know if it's empty.
//
// The ilist class is implemented by allocating a 'tail' node when the list is
// created (using ilist_traits<>::createSentinel()). This tail node is
// absolutely required because the user must be able to compute end()-1. Because
// of this, users of the direct next/prev links will see an extra link on the
// end of the list, which should be ignored.
//
// Requirements for a user of this list:
//
// 1. The user must provide {g|s}et{Next|Prev} methods, or specialize
// ilist_traits to provide an alternate way of getting and setting next and
// prev links.
//
//===----------------------------------------------------------------------===//

21
include/llvm/ADT/ilist_node.h
Просмотреть файл

@ -1,15 +1,16 @@
//==-- llvm/ADT/ilist_node.h - Intrusive Linked List Helper ------*- C++ -*-==//
///////////////////////////////////////////////////////////////////////////////
// //
// ilist_node.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the ilist_node class template, which is a convenient //
// base class for creating classes that can be used with ilists. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the ilist_node class template, which is a convenient
// base class for creating classes that can be used with ilists.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_ILIST_NODE_H
#define LLVM_ADT_ILIST_NODE_H

15
include/llvm/ADT/iterator.h
Просмотреть файл

@ -1,12 +1,11 @@
//===- iterator.h - Utilities for using and defining iterators --*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// iterator.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
///////////////////////////////////////////////////////////////////////////////
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_ITERATOR_H
#define LLVM_ADT_ITERATOR_H

29
include/llvm/ADT/iterator_range.h
Просмотреть файл

@ -1,21 +1,20 @@
//===- iterator_range.h - A range adaptor for iterators ---------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// iterator_range.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
/// \file //
/// This provides a very simple, boring adaptor for a begin and end iterator //
/// into a range type. This should be used to build range views that work well//
/// with range based for loops and range based constructors. //
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
/// \file
/// This provides a very simple, boring adaptor for a begin and end iterator
/// into a range type. This should be used to build range views that work well
/// with range based for loops and range based constructors.
///
/// Note that code here follows more standards-based coding conventions as it//
/// is mirroring proposed interfaces for standardization. //
/// Note that code here follows more standards-based coding conventions as it
/// is mirroring proposed interfaces for standardization.
///
// //
///////////////////////////////////////////////////////////////////////////////
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_ITERATOR_RANGE_H
#define LLVM_ADT_ITERATOR_RANGE_H

61
include/llvm/Analysis/AliasAnalysis.h
Просмотреть файл

@ -1,38 +1,39 @@
//===- llvm/Analysis/AliasAnalysis.h - Alias Analysis Interface -*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// AliasAnalysis.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the generic AliasAnalysis interface, which is used as the//
// common interface used by all clients of alias analysis information, and //
// implemented by all alias analysis implementations. Mod/Ref information is//
// also captured by this interface. //
//
// Implementations of this interface must implement the various virtual methods,//
// which automatically provides functionality for the entire suite of client //
// APIs. //
// The LLVM Compiler Infrastructure
//
// This API identifies memory regions with the MemoryLocation class. The pointer//
// component specifies the base memory address of the region. The Size specifies//
// the maximum size (in address units) of the memory region, or //
// MemoryLocation::UnknownSize if the size is not known. The TBAA tag //
// identifies the "type" of the memory reference; see the //
// TypeBasedAliasAnalysis class for details. //
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
// Some non-obvious details include: //
// - Pointers that point to two completely different objects in memory never//
// alias, regardless of the value of the Size component. //
// - NoAlias doesn't imply inequal pointers. The most obvious example of this//
// is two pointers to constant memory. Even if they are equal, constant //
// memory is never stored to, so there will never be any dependencies. //
// In this and other situations, the pointers may be both NoAlias and //
// MustAlias at the same time. The current API can only return one result,//
// though this is rarely a problem in practice. //
//===----------------------------------------------------------------------===//
//
///////////////////////////////////////////////////////////////////////////////
// This file defines the generic AliasAnalysis interface, which is used as the
// common interface used by all clients of alias analysis information, and
// implemented by all alias analysis implementations. Mod/Ref information is
// also captured by this interface.
//
// Implementations of this interface must implement the various virtual methods,
// which automatically provides functionality for the entire suite of client
// APIs.
//
// This API identifies memory regions with the MemoryLocation class. The pointer
// component specifies the base memory address of the region. The Size specifies
// the maximum size (in address units) of the memory region, or
// MemoryLocation::UnknownSize if the size is not known. The TBAA tag
// identifies the "type" of the memory reference; see the
// TypeBasedAliasAnalysis class for details.
//
// Some non-obvious details include:
// - Pointers that point to two completely different objects in memory never
// alias, regardless of the value of the Size component.
// - NoAlias doesn't imply inequal pointers. The most obvious example of this
// is two pointers to constant memory. Even if they are equal, constant
// memory is never stored to, so there will never be any dependencies.
// In this and other situations, the pointers may be both NoAlias and
// MustAlias at the same time. The current API can only return one result,
// though this is rarely a problem in practice.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_ALIASANALYSIS_H
#define LLVM_ANALYSIS_ALIASANALYSIS_H

25
include/llvm/Analysis/AliasSetTracker.h
Просмотреть файл

@ -1,17 +1,18 @@
//===- llvm/Analysis/AliasSetTracker.h - Build Alias Sets -------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// AliasSetTracker.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines two classes: AliasSetTracker and AliasSet. These interface//
// are used to classify a collection of pointer references into a maximal number//
// of disjoint sets. Each AliasSet object constructed by the AliasSetTracker//
// object refers to memory disjoint from the other sets. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines two classes: AliasSetTracker and AliasSet. These interface
// are used to classify a collection of pointer references into a maximal number
// of disjoint sets. Each AliasSet object constructed by the AliasSetTracker
// object refers to memory disjoint from the other sets.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_ALIASSETTRACKER_H
#define LLVM_ANALYSIS_ALIASSETTRACKER_H

23
include/llvm/Analysis/AssumptionCache.h
Просмотреть файл

@ -1,16 +1,17 @@
//===- llvm/Analysis/AssumptionCache.h - Track @llvm.assume ---*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// AssumptionCache.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file contains a pass that keeps track of @llvm.assume intrinsics in //
// the functions of a module (allowing assumptions within any function to be //
// found cheaply by other parts of the optimizer). //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains a pass that keeps track of @llvm.assume intrinsics in
// the functions of a module (allowing assumptions within any function to be
// found cheaply by other parts of the optimizer).
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_ASSUMPTIONCACHE_H
#define LLVM_ANALYSIS_ASSUMPTIONCACHE_H

19
include/llvm/Analysis/BlockFrequencyInfo.h
Просмотреть файл

@ -1,14 +1,15 @@
//===- BlockFrequencyInfo.h - Block Frequency Analysis ----------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// BlockFrequencyInfo.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// Loops should be simplified before this analysis. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Loops should be simplified before this analysis.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H
#define LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H

21
include/llvm/Analysis/BlockFrequencyInfoImpl.h
Просмотреть файл

@ -1,15 +1,16 @@
//==- BlockFrequencyInfoImpl.h - Block Frequency Implementation -*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// BlockFrequencyInfoImpl.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// Shared implementation of BlockFrequency for IR and Machine Instructions. //
// See the documentation below for BlockFrequencyInfoImpl for details. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Shared implementation of BlockFrequency for IR and Machine Instructions.
// See the documentation below for BlockFrequencyInfoImpl for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_BLOCKFREQUENCYINFOIMPL_H
#define LLVM_ANALYSIS_BLOCKFREQUENCYINFOIMPL_H

19
include/llvm/Analysis/BranchProbabilityInfo.h
Просмотреть файл

@ -1,14 +1,15 @@
//===--- BranchProbabilityInfo.h - Branch Probability Analysis --*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// BranchProbabilityInfo.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This pass is used to evaluate branch probabilties. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This pass is used to evaluate branch probabilties.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_BRANCHPROBABILITYINFO_H
#define LLVM_ANALYSIS_BRANCHPROBABILITYINFO_H

21
include/llvm/Analysis/CFG.h
Просмотреть файл

@ -1,15 +1,16 @@
//===-- Analysis/CFG.h - BasicBlock Analyses --------------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// CFG.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This family of functions performs analyses on basic blocks, and instructions//
// contained within basic blocks. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This family of functions performs analyses on basic blocks, and instructions
// contained within basic blocks.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_CFG_H
#define LLVM_ANALYSIS_CFG_H

21
include/llvm/Analysis/CFGPrinter.h
Просмотреть файл

@ -1,15 +1,16 @@
//===-- CFGPrinter.h - CFG printer external interface -----------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// CFGPrinter.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines external functions that can be called to explicitly //
// instantiate the CFG printer. //
//
///////////////////////////////////////////////////////////////////////////////
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines external functions that can be called to explicitly
// instantiate the CFG printer.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_CFGPRINTER_H
#define LLVM_ANALYSIS_CFGPRINTER_H

33
include/llvm/Analysis/CGSCCPassManager.h
Просмотреть файл

@ -1,23 +1,22 @@
//===- CGSCCPassManager.h - Call graph pass management ----------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// CGSCCPassManager.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
/// \file //
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
/// \file
///
/// This header provides classes for managing passes over SCCs of the call //
/// graph. These passes form an important component of LLVM's interprocedural//
/// optimizations. Because they operate on the SCCs of the call graph, and they//
/// wtraverse the graph in post order, they can effectively do pair-wise //
/// interprocedural optimizations for all call edges in the program. At each //
/// call site edge, the callee has already been optimized as much as is //
/// possible. This in turn allows very accurate analysis of it for IPO. //
/// This header provides classes for managing passes over SCCs of the call
/// graph. These passes form an important component of LLVM's interprocedural
/// optimizations. Because they operate on the SCCs of the call graph, and they
/// wtraverse the graph in post order, they can effectively do pair-wise
/// interprocedural optimizations for all call edges in the program. At each
/// call site edge, the callee has already been optimized as much as is
/// possible. This in turn allows very accurate analysis of it for IPO.
///
// //
///////////////////////////////////////////////////////////////////////////////
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_CGSCCPASSMANAGER_H
#define LLVM_ANALYSIS_CGSCCPASSMANAGER_H

80
include/llvm/Analysis/CallGraph.h
Просмотреть файл

@ -1,51 +1,51 @@
//===- CallGraph.h - Build a Module's call graph ----------------*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// CallGraph.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
/// \file //
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
/// \file
///
/// This file provides interfaces used to build and manipulate a call graph, //
/// which is a very useful tool for interprocedural optimization. //
/// This file provides interfaces used to build and manipulate a call graph,
/// which is a very useful tool for interprocedural optimization.
///
/// Every function in a module is represented as a node in the call graph. The//
/// callgraph node keeps track of which functions are called by the function //
/// corresponding to the node. //
/// Every function in a module is represented as a node in the call graph. The
/// callgraph node keeps track of which functions are called by the function
/// corresponding to the node.
///
/// A call graph may contain nodes where the function that they correspond to//
/// is null. These 'external' nodes are used to represent control flow that is//
/// not represented (or analyzable) in the module. In particular, this //
/// analysis builds one external node such that: //
/// 1. All functions in the module without internal linkage will have edges//
/// from this external node, indicating that they could be called by //
/// functions outside of the module. //
/// 2. All functions whose address is used for something more than a direct//
/// call, for example being stored into a memory location will also have//
/// an edge from this external node. Since they may be called by an //
/// unknown caller later, they must be tracked as such. //
/// A call graph may contain nodes where the function that they correspond to
/// is null. These 'external' nodes are used to represent control flow that is
/// not represented (or analyzable) in the module. In particular, this
/// analysis builds one external node such that:
/// 1. All functions in the module without internal linkage will have edges
/// from this external node, indicating that they could be called by
/// functions outside of the module.
/// 2. All functions whose address is used for something more than a direct
/// call, for example being stored into a memory location will also have
/// an edge from this external node. Since they may be called by an
/// unknown caller later, they must be tracked as such.
///
/// There is a second external node added for calls that leave this module. //
/// Functions have a call edge to the external node iff: //
/// 1. The function is external, reflecting the fact that they could call //
/// anything without internal linkage or that has its address taken. //
/// 2. The function contains an indirect function call. //
/// There is a second external node added for calls that leave this module.
/// Functions have a call edge to the external node iff:
/// 1. The function is external, reflecting the fact that they could call
/// anything without internal linkage or that has its address taken.
/// 2. The function contains an indirect function call.
///
/// As an extension in the future, there may be multiple nodes with a null //
/// function. These will be used when we can prove (through pointer analysis)//
/// that an indirect call site can call only a specific set of functions. //
/// As an extension in the future, there may be multiple nodes with a null
/// function. These will be used when we can prove (through pointer analysis)
/// that an indirect call site can call only a specific set of functions.
///
/// Because of these properties, the CallGraph captures a conservative superset//
/// of all of the caller-callee relationships, which is useful for //
/// transformations. //
/// Because of these properties, the CallGraph captures a conservative superset
/// of all of the caller-callee relationships, which is useful for
/// transformations.
///
/// The CallGraph class also attempts to figure out what the root of the //
/// CallGraph is, which it currently does by looking for a function named //
/// 'main'. If no function named 'main' is found, the external node is used as//
/// the entry node, reflecting the fact that any function without internal //
/// linkage could be called into (which is common for libraries). //
/// The CallGraph class also attempts to figure out what the root of the
/// CallGraph is, which it currently does by looking for a function named
/// 'main'. If no function named 'main' is found, the external node is used as
/// the entry node, reflecting the fact that any function without internal
/// linkage could be called into (which is common for libraries).
///
//===----------------------------------------------------------------------===//

31
include/llvm/Analysis/CallGraphSCCPass.h
Просмотреть файл

@ -1,21 +1,22 @@
//===- CallGraphSCCPass.h - Pass that operates BU on call graph -*- C++ -*-===//
///////////////////////////////////////////////////////////////////////////////
// //
// CallGraphSCCPass.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// Licensed under the MIT license. See COPYRIGHT in the project root for //
// full license information. //
// //
// This file defines the CallGraphSCCPass class, which is used for passes which//
// are implemented as bottom-up traversals on the call graph. Because there may//
// be cycles in the call graph, passes of this type operate on the call-graph in//
// SCC order: that is, they process function bottom-up, except for recursive //
// functions, which they process all at once. //
//
// These passes are inherently interprocedural, and are required to keep the //
// call graph up-to-date if they do anything which could modify it. //
// The LLVM Compiler Infrastructure
//
///////////////////////////////////////////////////////////////////////////////
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the CallGraphSCCPass class, which is used for passes which
// are implemented as bottom-up traversals on the call graph. Because there may
// be cycles in the call graph, passes of this type operate on the call-graph in
// SCC order: that is, they process function bottom-up, except for recursive
// functions, which they process all at once.
//
// These passes are inherently interprocedural, and are required to keep the
// call graph up-to-date if they do anything which could modify it.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_CALLGRAPHSCCPASS_H
#define LLVM_ANALYSIS_CALLGRAPHSCCPASS_H

Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше