File-level source notices; original source paths are shown. llvm/lib/Support/AArch64BuildAttributes.cpp //===-- AArch64BuildAttributes.cpp - AArch64 Build Attributes -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/ABIBreak.cpp //===----- lib/Support/ABIBreak.cpp - EnableABIBreakingChecks -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/AMDGPUMetadata.cpp //===--- AMDGPUMetadata.cpp -------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // /// \file /// AMDGPU metadata definitions and in-memory representations. /// // //===----------------------------------------------------------------------===// llvm/lib/Support/APFixedPoint.cpp //===- APFixedPoint.cpp - Fixed point constant handling ---------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // /// \file /// Defines the implementation for the fixed point number interface. // //===----------------------------------------------------------------------===// llvm/lib/Support/APFloat.cpp //===-- APFloat.cpp - Implement APFloat class -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a class to represent arbitrary precision floating // point values and provide a variety of arithmetic operations on them. // //===----------------------------------------------------------------------===// llvm/lib/Support/APInt.cpp //===-- APInt.cpp - Implement APInt class ---------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a class to represent arbitrary precision integer // constant values and provide a variety of arithmetic operations on them. // //===----------------------------------------------------------------------===// llvm/lib/Support/APSInt.cpp //===-- llvm/ADT/APSInt.cpp - Arbitrary Precision Signed Int ---*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the APSInt class, which is a simple class that // represents an arbitrary sized integer that knows its signedness. // //===----------------------------------------------------------------------===// llvm/lib/Support/ARMAttributeParser.cpp //===- ARMAttributeParser.cpp - ARM Attribute Information Printer ---------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/ARMBuildAttributes.cpp //===-- ARMBuildAttrs.cpp - ARM Build Attributes --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/ARMWinEH.cpp //===-- ARMWinEH.cpp - Windows on ARM EH Support Functions ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/Allocator.cpp //===--- Allocator.cpp - Simple memory allocation abstraction -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the BumpPtrAllocator interface. // //===----------------------------------------------------------------------===// llvm/lib/Support/Atomic.cpp //===-- Atomic.cpp - Atomic Operations --------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements atomic operations. // //===----------------------------------------------------------------------===// llvm/lib/Support/AutoConvert.cpp //===- AutoConvert.cpp - Auto conversion between ASCII/EBCDIC -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains functions used for auto conversion between // ASCII/EBCDIC codepages specific to z/OS. // //===----------------------------------------------------------------------===// #ifdef __MVS__ llvm/lib/Support/BLAKE3/blake3.c /*===-- blake3.c - BLAKE3 C Implementation ------------------------*- C -*-===*\ |* *| |* Released into the public domain with CC0 1.0 *| |* See 'llvm/lib/Support/BLAKE3/LICENSE' for info. *| |* SPDX-License-Identifier: CC0-1.0 *| |* *| \*===----------------------------------------------------------------------===*/ llvm/lib/Support/BalancedPartitioning.cpp //===- BalancedPartitioning.cpp -------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements BalancedPartitioning, a recursive balanced graph // partitioning algorithm. // //===----------------------------------------------------------------------===// llvm/lib/Support/Base64.cpp //===- Base64.cpp ---------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define INVALID_BASE64_BYTE 64 llvm/lib/Support/BinaryStreamError.cpp //===- BinaryStreamError.cpp - Error extensions for streams -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/BinaryStreamReader.cpp //===- BinaryStreamReader.cpp - Reads objects from a binary stream --------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/BinaryStreamRef.cpp //===- BinaryStreamRef.cpp - ----------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/BinaryStreamWriter.cpp //===- BinaryStreamWriter.cpp - Writes objects to a BinaryStream ----------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/BlockFrequency.cpp //====--------------- lib/Support/BlockFrequency.cpp -----------*- C++ -*-====// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements Block Frequency class. // //===----------------------------------------------------------------------===// llvm/lib/Support/BranchProbability.cpp //===-------------- lib/Support/BranchProbability.cpp -----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements Branch Probability class. // //===----------------------------------------------------------------------===// llvm/lib/Support/BuryPointer.cpp //===- BuryPointer.cpp - Memory Manipulation/Leak ---------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/COM.cpp //===-- COM.cpp - Implement COM utility classes -----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements utility classes related to COM. // //===----------------------------------------------------------------------===// llvm/lib/Support/CRC.cpp //===--- CRC.cpp - Cyclic Redundancy Check implementation -----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains implementations of CRC functions. // // The implementation technique is the one mentioned in: // D. V. Sarwate. 1988. Computation of cyclic redundancy checks via table // look-up. Commun. ACM 31, 8 (August 1988) // // See also Ross N. Williams "A Painless Guide to CRC Error Detection // Algorithms" (https://zlib.net/crc_v3.txt) or Hacker's Delight (2nd ed.) // Chapter 14 (Figure 14-7 in particular) for how the algorithm works. // //===----------------------------------------------------------------------===// llvm/lib/Support/CSKYAttributeParser.cpp //===-- CSKYAttributeParser.cpp - CSKY Attribute Parser -----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/CSKYAttributes.cpp //===-- CSKYAttributes.cpp - CSKY Attributes ------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/CachePruning.cpp //===-CachePruning.cpp - LLVM Cache Directory Pruning ---------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the pruning of a directory based on least recently used. // //===----------------------------------------------------------------------===// llvm/lib/Support/Caching.cpp //===-Caching.cpp - LLVM Local File Cache ---------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the localCache function, which simplifies creating, // adding to, and querying a local file system cache. localCache takes care of // periodically pruning older files from the cache using a CachePruningPolicy. // //===----------------------------------------------------------------------===// llvm/lib/Support/Chrono.cpp //===- Support/Chrono.cpp - Utilities for Timing Manipulation ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/CodeGenCoverage.cpp //===- lib/Support/CodeGenCoverage.cpp -------------------------------------==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// This file implements the CodeGenCoverage class. //===----------------------------------------------------------------------===// llvm/lib/Support/CommandLine.cpp //===-- CommandLine.cpp - Command line parser implementation --------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This class implements a command line argument processor that is useful when // creating a tool. It provides a simple, minimalistic interface that is easily // extensible and supports nonlocal (library) command line options. // // Note that rather than trying to figure out what this code does, you could try // reading the library documentation located in docs/CommandLine.html // //===----------------------------------------------------------------------===// llvm/lib/Support/Compression.cpp //===--- Compression.cpp - Compression implementation ---------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements compression functions. // //===----------------------------------------------------------------------===// llvm/lib/Support/ConvertEBCDIC.cpp //===--- ConvertEBCDIC.cpp - UTF8/EBCDIC CharSet Conversion -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file provides utility functions for converting between EBCDIC-1047 and /// UTF-8. /// /// //===----------------------------------------------------------------------===// llvm/lib/Support/ConvertUTF.cpp /*===--- ConvertUTF.c - Universal Character Names conversions ---------------=== * * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * See https://llvm.org/LICENSE.txt for license information. * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * *===------------------------------------------------------------------------=*/ /* * Copyright © 1991-2015 Unicode, Inc. All rights reserved. * Distributed under the Terms of Use in * http://www.unicode.org/copyright.html. * * Permission is hereby granted, free of charge, to any person obtaining * a copy of the Unicode data files and any associated documentation * (the "Data Files") or Unicode software and any associated documentation * (the "Software") to deal in the Data Files or Software * without restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, and/or sell copies of * the Data Files or Software, and to permit persons to whom the Data Files * or Software are furnished to do so, provided that * (a) this copyright and permission notice appear with all copies * of the Data Files or Software, * (b) this copyright and permission notice appear in associated * documentation, and * (c) there is clear notice in each modified Data File or in the Software * as well as in the documentation associated with the Data File(s) or * Software that the data or software has been modified. * * THE DATA FILES AND SOFTWARE ARE 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 OF THIRD PARTY RIGHTS. * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS * NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL * DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THE DATA FILES OR SOFTWARE. * * Except as contained in this notice, the name of a copyright holder * shall not be used in advertising or otherwise to promote the sale, * use or other dealings in these Data Files or Software without prior * written authorization of the copyright holder. */ /* --------------------------------------------------------------------- Conversions between UTF32, UTF-16, and UTF-8. Source code file. Author: Mark E. Davis, 1994. Rev History: Rick McGowan, fixes & updates May 2001. Sept 2001: fixed const & error conditions per mods suggested by S. Parent & A. Lillich. June 2002: Tim Dodd added detection and handling of incomplete source sequences, enhanced error detection, added casts to eliminate compiler warnings. July 2003: slight mods to back out aggressive FFFE detection. Jan 2004: updated switches in from-UTF8 conversions. Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions. See the header file "ConvertUTF.h" for complete documentation. ------------------------------------------------------------------------ */ llvm/lib/Support/ConvertUTFWrapper.cpp //===-- ConvertUTFWrapper.cpp - Wrap ConvertUTF.h with clang data types -----=== // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/CrashRecoveryContext.cpp //===--- CrashRecoveryContext.cpp - Crash Recovery ------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/DAGDeltaAlgorithm.cpp //===--- DAGDeltaAlgorithm.cpp - A DAG Minimization Algorithm --*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception //===----------------------------------------------------------------------===// // // The algorithm we use attempts to exploit the dependency information by // minimizing top-down. We start by constructing an initial root set R, and // then iteratively: // // 1. Minimize the set R using the test predicate: // P'(S) = P(S union pred*(S)) // // 2. Extend R to R' = R union pred(R). // // until a fixed point is reached. // // The idea is that we want to quickly prune entire portions of the graph, so we // try to find high-level nodes that can be eliminated with all of their // dependents. // // FIXME: The current algorithm doesn't actually provide a strong guarantee // about the minimality of the result. The problem is that after adding nodes to // the required set, we no longer consider them for elimination. For strictly // well formed predicates, this doesn't happen, but it commonly occurs in // practice when there are unmodelled dependencies. I believe we can resolve // this by allowing the required set to be minimized as well, but need more test // cases first. // //===----------------------------------------------------------------------===// llvm/lib/Support/DJB.cpp //===-- Support/DJB.cpp ---DJB Hash -----------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains support for the DJ Bernstein hash function. // //===----------------------------------------------------------------------===// llvm/lib/Support/DataExtractor.cpp //===-- DataExtractor.cpp -------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/Debug.cpp //===-- Debug.cpp - An easy way to add debug output to your code ----------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a handy way of adding debugging information to your // code, without it being enabled all of the time, and without having to add // command line options to enable it. // // In particular, just wrap your code with the LLVM_DEBUG() macro, and it will // be enabled automatically if you specify '-debug' on the command-line. // Alternatively, you can also use the SET_DEBUG_TYPE("foo") macro to specify // that your debug code belongs to class "foo". Then, on the command line, you // can specify '-debug-only=foo' to enable JUST the debug information for the // foo class. // // When compiling without assertions, the -debug-* options and all code in // LLVM_DEBUG() statements disappears, so it does not affect the runtime of the // code. // //===----------------------------------------------------------------------===// llvm/lib/Support/DeltaAlgorithm.cpp //===--- DeltaAlgorithm.cpp - A Set Minimization Algorithm -----*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception //===----------------------------------------------------------------------===// llvm/lib/Support/DeltaTree.cpp //===- DeltaTree.cpp - B-Tree for Rewrite Delta tracking ------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the DeltaTree and related classes. // //===----------------------------------------------------------------------===// llvm/lib/Support/DivisionByConstantInfo.cpp //===----- DivisionByConstantInfo.cpp - division by constant -*- C++ -*----===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// This file implements support for optimizing divisions by a constant /// //===----------------------------------------------------------------------===// llvm/lib/Support/DynamicAPInt.cpp //===- DynamicAPInt.cpp - DynamicAPInt Implementation -----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/DynamicLibrary.cpp //===-- DynamicLibrary.cpp - Runtime link/load libraries --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the operating system DynamicLibrary concept. // //===----------------------------------------------------------------------===// llvm/lib/Support/ELFAttributeParser.cpp //===--- ELFAttributeParser.cpp - ELF Attribute Parser --------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/ELFAttributes.cpp //===-- ELFAttributes.cpp - ELF Attributes --------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/Errno.cpp //===- Errno.cpp - errno support --------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the errno wrappers. // //===----------------------------------------------------------------------===// llvm/lib/Support/Error.cpp //===----- lib/Support/Error.cpp - Error and associated utilities ---------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/ErrorHandling.cpp //===- lib/Support/ErrorHandling.cpp - Callbacks for errors ---------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines an API used to indicate fatal error conditions. Non-fatal // errors (most of them) should be handled through LLVMContext. // //===----------------------------------------------------------------------===// llvm/lib/Support/ExponentialBackoff.cpp //===- llvm/Support/ExponentialBackoff.h ------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/ExtensibleRTTI.cpp //===----- lib/Support/ExtensibleRTTI.cpp - ExtensibleRTTI utilities ------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/FileCollector.cpp //===-- FileCollector.cpp ---------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/FileOutputBuffer.cpp //===- FileOutputBuffer.cpp - File Output Buffer ----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Utility for creating a in-memory buffer that will be written to a file. // //===----------------------------------------------------------------------===// llvm/lib/Support/FileUtilities.cpp //===- Support/FileUtilities.cpp - File System Utilities ------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a family of utility functions which are useful for doing // various things with files. // //===----------------------------------------------------------------------===// llvm/lib/Support/FloatingPointMode.cpp //===- FloatingPointMode.cpp ------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/FoldingSet.cpp //===-- Support/FoldingSet.cpp - Uniquing Hash Set --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a hash set that can be used to remove duplication of // nodes in a graph. // //===----------------------------------------------------------------------===// llvm/lib/Support/FormatVariadic.cpp //===- FormatVariadic.cpp - Format string parsing and analysis ----*-C++-*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception //===----------------------------------------------------------------------===// llvm/lib/Support/FormattedStream.cpp //===-- llvm/Support/FormattedStream.cpp - Formatted streams ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains the implementation of formatted_raw_ostream. // //===----------------------------------------------------------------------===// llvm/lib/Support/GlobPattern.cpp //===-- GlobPattern.cpp - Glob pattern matcher implementation -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a glob pattern matcher. // //===----------------------------------------------------------------------===// llvm/lib/Support/GraphWriter.cpp //===- GraphWriter.cpp - Implements GraphWriter support routines ----------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements misc. GraphWriter support routines. // //===----------------------------------------------------------------------===// llvm/lib/Support/HexagonAttributeParser.cpp //===-- HexagonAttributeParser.cpp - Hexagon Attribute Parser -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/HexagonAttributes.cpp //===-- HexagonAttributes.cpp - Qualcomm Hexagon Attributes ---------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/InitLLVM.cpp //===-- InitLLVM.cpp -----------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/InstructionCost.cpp //===- InstructionCost.cpp --------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// This file includes the function definitions for the InstructionCost class /// that is used when calculating the cost of an instruction, or a group of /// instructions. //===----------------------------------------------------------------------===// llvm/lib/Support/IntEqClasses.cpp //===-- llvm/ADT/IntEqClasses.cpp - Equivalence Classes of Integers -------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // 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. // //===----------------------------------------------------------------------===// llvm/lib/Support/IntervalMap.cpp //===- lib/Support/IntervalMap.cpp - A sorted interval map ----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the few non-templated functions in IntervalMap. // //===----------------------------------------------------------------------===// llvm/lib/Support/JSON.cpp //=== JSON.cpp - JSON value, parsing and serialization - C++ -----------*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===---------------------------------------------------------------------===// llvm/lib/Support/KnownBits.cpp //===-- KnownBits.cpp - Stores known zeros/ones ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains a class for representing known zeros and ones used by // computeKnownBits. // //===----------------------------------------------------------------------===// llvm/lib/Support/LEB128.cpp //===- LEB128.cpp - LEB128 utility functions implementation -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements some utility functions for encoding SLEB128 and // ULEB128 values. // //===----------------------------------------------------------------------===// llvm/lib/Support/LineIterator.cpp //===- LineIterator.cpp - Implementation of line iteration ----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/LockFileManager.cpp //===--- LockFileManager.cpp - File-level Locking Utility------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/MD5.cpp /* * This code is derived from (original license follows): * * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. * MD5 Message-Digest Algorithm (RFC 1321). * * Homepage: * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 * * Author: * Alexander Peslyak, better known as Solar Designer * * This software was written by Alexander Peslyak in 2001. No copyright is * claimed, and the software is hereby placed in the public domain. * In case this attempt to disclaim copyright and place the software in the * public domain is deemed null and void, then the software is * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the * general public under the following terms: * * Redistribution and use in source and binary forms, with or without * modification, are permitted. * * There's ABSOLUTELY NO WARRANTY, express or implied. * * (This is a heavily cut-down "BSD license".) * * This differs from Colin Plumb's older public domain implementation in that * no exactly 32-bit integer data type is required (any 32-bit or wider * unsigned integer data type will do), there's no compile-time endianness * configuration, and the function prototypes match OpenSSL's. No code from * Colin Plumb's implementation has been reused; this comment merely compares * the properties of the two independent implementations. * * The primary goals of this implementation are portability and ease of use. * It is meant to be fast, but not as fast as possible. Some known * optimizations are not included to reduce source code size and avoid * compile-time configuration. */ llvm/lib/Support/MSP430AttributeParser.cpp //===-- MSP430AttributeParser.cpp - MSP430 Attribute Parser ---------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/MSP430Attributes.cpp //===-- MSP430Attributes.cpp - MSP430 Attributes --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/ManagedStatic.cpp //===-- ManagedStatic.cpp - Static Global wrapper -------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the ManagedStatic class and llvm_shutdown(). // //===----------------------------------------------------------------------===// llvm/lib/Support/MathExtras.cpp //===-- MathExtras.cpp - Implement the MathExtras header --------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the MathExtras.h header // //===----------------------------------------------------------------------===// llvm/lib/Support/MemAlloc.cpp //===- MemAlloc.cpp - Memory allocation functions -------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/Memory.cpp //===- Memory.cpp - Memory Handling Support ---------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines some helpful functions for allocating memory and dealing // with memory mapped files // //===----------------------------------------------------------------------===// llvm/lib/Support/MemoryBuffer.cpp //===--- MemoryBuffer.cpp - Memory Buffer implementation ------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the MemoryBuffer interface. // //===----------------------------------------------------------------------===// llvm/lib/Support/MemoryBufferRef.cpp //===- MemoryBufferRef.cpp - Memory Buffer Reference ----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the MemoryBufferRef interface. // //===----------------------------------------------------------------------===// llvm/lib/Support/ModRef.cpp //===--- ModRef.cpp - Memory effect modeling --------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements ModRef and MemoryEffects misc functions. // //===----------------------------------------------------------------------===// llvm/lib/Support/NativeFormatting.cpp //===- NativeFormatting.cpp - Low level formatting helpers -------*- C++-*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/OptimizedStructLayout.cpp //===--- OptimizedStructLayout.cpp - Optimal data layout algorithm ----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the performOptimizedStructLayout interface. // //===----------------------------------------------------------------------===// llvm/lib/Support/OptionStrCmp.cpp //===- OptionStrCmp.cpp - Option String Comparison --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/Optional.cpp //===- Optional.cpp - Optional values ---------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/PGOOptions.cpp //===------ PGOOptions.cpp -- PGO option tunables --------------*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/Parallel.cpp //===- llvm/Support/Parallel.cpp - Parallel algorithms --------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/Path.cpp //===-- Path.cpp - Implement OS Path Concept ------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the operating system Path API. // //===----------------------------------------------------------------------===// llvm/lib/Support/PluginLoader.cpp //===-- PluginLoader.cpp - Implement -load command line option ------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the -load command line option handler. // //===----------------------------------------------------------------------===// #define DONT_GET_PLUGIN_LOADER_OPTION llvm/lib/Support/PrettyStackTrace.cpp //===- PrettyStackTrace.cpp - Pretty Crash Handling -----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines some helpful functions for dealing with the possibility of // Unix signals occurring while your program is running. // //===----------------------------------------------------------------------===// llvm/lib/Support/Process.cpp //===-- Process.cpp - Implement OS Process Concept --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the operating system Process concept. // //===----------------------------------------------------------------------===// llvm/lib/Support/Program.cpp //===-- Program.cpp - Implement OS Program Concept --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the operating system Program concept. // //===----------------------------------------------------------------------===// llvm/lib/Support/RISCVAttributeParser.cpp //===-- RISCVAttributeParser.cpp - RISCV Attribute Parser -----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/RISCVAttributes.cpp //===-- RISCVAttributes.cpp - RISCV Attributes ----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/RISCVISAUtils.cpp //===-- RISCVISAUtils.cpp - RISC-V ISA Utilities --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Utilities shared by TableGen and RISCVISAInfo. // //===----------------------------------------------------------------------===// llvm/lib/Support/RWMutex.cpp //===- RWMutex.cpp - Reader/Writer Mutual Exclusion Lock --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the llvm::sys::RWMutex class. // //===----------------------------------------------------------------------===// llvm/lib/Support/RandomNumberGenerator.cpp //===-- RandomNumberGenerator.cpp - Implement RNG class -------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements deterministic random number generation (RNG). // The current implementation is NOT cryptographically secure as it uses // the C++11 facilities. // //===----------------------------------------------------------------------===// llvm/lib/Support/Regex.cpp //===-- Regex.cpp - Regular Expression matcher implementation -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a POSIX regular expression matcher. // //===----------------------------------------------------------------------===// llvm/lib/Support/RewriteBuffer.cpp //===- RewriteBuffer.h - Buffer rewriting interface -----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/RewriteRope.cpp //===- RewriteRope.cpp - Rope specialized for rewriter --------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the RewriteRope class, which is a powerful string. // //===----------------------------------------------------------------------===// llvm/lib/Support/SHA1.cpp //====- SHA1.cpp - Private copy of the SHA1 implementation ---*- C++ -* ======// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This code is taken from public domain // (http://oauth.googlecode.com/svn/code/c/liboauth/src/sha1.c and // http://cvsweb.netbsd.org/bsdweb.cgi/src/common/lib/libc/hash/sha1/sha1.c?rev=1.6) // and modified by wrapping it in a C++ interface for LLVM, // and removing unnecessary code. // //===----------------------------------------------------------------------===// llvm/lib/Support/SHA256.cpp //====- SHA256.cpp - SHA256 implementation ---*- C++ -* ======// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /* * The SHA-256 Secure Hash Standard was published by NIST in 2002. * * http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf * * The implementation is based on nacl's sha256 implementation [0] and LLVM's * pre-exsiting SHA1 code [1]. * * [0] https://hyperelliptic.org/nacl/nacl-20110221.tar.bz2 (public domain * code) * [1] llvm/lib/Support/SHA1.{h,cpp} */ //===----------------------------------------------------------------------===// llvm/lib/Support/ScaledNumber.cpp //==- lib/Support/ScaledNumber.cpp - Support for scaled numbers -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Implementation of some scaled number algorithms. // //===----------------------------------------------------------------------===// llvm/lib/Support/Signals.cpp //===- Signals.cpp - Signal Handling support --------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines some helpful functions for dealing with the possibility of // Unix signals occurring while your program is running. // //===----------------------------------------------------------------------===// llvm/lib/Support/Signposts.cpp //===-- Signposts.cpp - Interval debug annotations ------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/SipHash.cpp //===--- SipHash.cpp - An ABI-stable string hash --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements an ABI-stable string hash based on SipHash, used to // compute ptrauth discriminators. // //===----------------------------------------------------------------------===// llvm/lib/Support/SlowDynamicAPInt.cpp //===- SlowDynamicAPInt.cpp - SlowDynamicAPInt Implementation -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/SmallPtrSet.cpp //===- llvm/ADT/SmallPtrSet.cpp - 'Normally small' pointer set ------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the SmallPtrSet class. See SmallPtrSet.h for an // overview of the algorithm. // //===----------------------------------------------------------------------===// llvm/lib/Support/SmallVector.cpp //===- llvm/ADT/SmallVector.cpp - 'Normally small' vectors ----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the SmallVector class. // //===----------------------------------------------------------------------===// llvm/lib/Support/SourceMgr.cpp //===- SourceMgr.cpp - Manager for Simple Source Buffers & Diagnostics ----===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the SourceMgr class. This class is used as a simple // substrate for diagnostics, llvm/lib/Support/SpecialCaseList.cpp //===-- SpecialCaseList.cpp - special case list for sanitizers ------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This is a utility class for instrumentation passes (like AddressSanitizer // or ThreadSanitizer) to avoid instrumenting some functions or global // variables, or to instrument some functions or global variables in a specific // way, based on a user-supplied list. // //===----------------------------------------------------------------------===// llvm/lib/Support/Statistic.cpp //===-- Statistic.cpp - Easy way to expose stats information --------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the 'Statistic' class, which is designed to be an easy // way to expose various success metrics from passes. These statistics are // printed at the end of a run, when the -stats command line option is enabled // 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 NumInstEliminated("GCSE", "Number of instructions killed"); // // Later, in the code: ++NumInstEliminated; // //===----------------------------------------------------------------------===// llvm/lib/Support/StringExtras.cpp //===-- StringExtras.cpp - Implement the StringExtras header --------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the StringExtras.h header // //===----------------------------------------------------------------------===// llvm/lib/Support/StringMap.cpp //===--- StringMap.cpp - String Hash table map implementation -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the StringMap class. // //===----------------------------------------------------------------------===// llvm/lib/Support/StringRef.cpp //===-- StringRef.cpp - Lightweight String References ---------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/StringSaver.cpp //===-- StringSaver.cpp ---------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/SuffixTree.cpp //===- llvm/Support/SuffixTree.cpp - Implement Suffix Tree ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the Suffix Tree class. // //===----------------------------------------------------------------------===// llvm/lib/Support/SuffixTreeNode.cpp //===- llvm/ADT/SuffixTreeNode.cpp - Nodes for SuffixTrees --------*- C++ //-*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines nodes for use within a SuffixTree. // //===----------------------------------------------------------------------===// llvm/lib/Support/SystemUtils.cpp //===- SystemUtils.cpp - Utilities for low-level system tasks -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains functions used to do a variety of low-level, often // system-specific, tasks. // //===----------------------------------------------------------------------===// llvm/lib/Support/TarWriter.cpp //===-- TarWriter.cpp - Tar archive file creator --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // TarWriter class provides a feature to create a tar archive file. // // I put emphasis on simplicity over comprehensiveness when implementing this // class because we don't need a full-fledged archive file generator in LLVM // at the moment. // // The filename field in the Unix V7 tar header is 100 bytes. Longer filenames // are stored using the PAX extension. The PAX header is standardized in // POSIX.1-2001. // // The struct definition of UstarHeader is copied from // https://www.freebsd.org/cgi/man.cgi?query=tar&sektion=5 // //===----------------------------------------------------------------------===// llvm/lib/Support/ThreadPool.cpp //==-- llvm/Support/ThreadPool.cpp - A ThreadPool implementation -*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a crude C++11 based thread pool. // //===----------------------------------------------------------------------===// llvm/lib/Support/Threading.cpp //===-- llvm/Support/Threading.cpp- Control multithreading mode --*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines helper functions for running LLVM in a multi-threaded // environment. // //===----------------------------------------------------------------------===// llvm/lib/Support/TimeProfiler.cpp //===-- TimeProfiler.cpp - Hierarchical Time Profiler ---------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements hierarchical time profiler. // //===----------------------------------------------------------------------===// llvm/lib/Support/Timer.cpp //===-- Timer.cpp - Interval Timing Support -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // /// \file Interval Timing implementation. // //===----------------------------------------------------------------------===// llvm/lib/Support/ToolOutputFile.cpp //===--- ToolOutputFile.cpp - Implement the ToolOutputFile class --------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This implements the ToolOutputFile class. // //===----------------------------------------------------------------------===// llvm/lib/Support/TrieRawHashMap.cpp //===- TrieRawHashMap.cpp -------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/Twine.cpp //===-- Twine.cpp - Fast Temporary String Concatenation -------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/TypeSize.cpp //===- TypeSize.cpp - Wrapper around type sizes------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/Unicode.cpp //===- llvm/Support/Unicode.cpp - Unicode character properties -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements functions that allow querying certain properties of // Unicode characters. // //===----------------------------------------------------------------------===// llvm/lib/Support/UnicodeNameToCodepoint.cpp //===- llvm/Support/UnicodeNameToCodepoint.cpp - Unicode character properties //-*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements functions to map the name or alias of a unicode // character to its codepoint. // //===----------------------------------------------------------------------===// llvm/lib/Support/UnicodeNameToCodepointGenerated.cpp //===------------- Support/UnicodeNameToCodepointGenerated.cpp ------------===// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements mapping the name of a unicode code point to its value. // // This file was generated using ./bin/UnicodeNameMappingGenerator. // Do not edit manually. // //===----------------------------------------------------------------------===// /* UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE See Terms of Use for definitions of Unicode Inc.’s Data Files and Software. NOTICE TO USER: Carefully read the following legal agreement. BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"), YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE. COPYRIGHT AND PERMISSION NOTICE Copyright © 1991-2022 Unicode, Inc. All rights reserved. Distributed under the Terms of Use in https://www.unicode.org/copyright.html. Permission is hereby granted, free of charge, to any person obtaining a copy of the Unicode data files and any associated documentation (the "Data Files") or Unicode software and any associated documentation (the "Software") to deal in the Data Files or Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the Data Files or Software, and to permit persons to whom the Data Files or Software are furnished to do so, provided that either (a) this copyright and permission notice appear with all copies of the Data Files or Software, or (b) this copyright and permission notice appear in associated Documentation. THE DATA FILES AND SOFTWARE ARE 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 OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA FILES OR SOFTWARE. Except as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in these Data Files or Software without prior written authorization of the copyright holder. */ llvm/lib/Support/Unix/Unix.h //===- llvm/Support/Unix/Unix.h - Common Unix Include File -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines things specific to Unix implementations. // //===----------------------------------------------------------------------===// #ifndef LLVM_LIB_SUPPORT_UNIX_UNIX_H #define LLVM_LIB_SUPPORT_UNIX_UNIX_H //===----------------------------------------------------------------------===// //=== WARNING: Implementation here must contain only generic UNIX code that //=== is guaranteed to work on all UNIX variants. //===----------------------------------------------------------------------===// llvm/lib/Support/Valgrind.cpp //===-- Valgrind.cpp - Implement Valgrind communication ---------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Defines Valgrind communication methods, if HAVE_VALGRIND_VALGRIND_H is // defined. If we have valgrind.h but valgrind isn't running, its macros are // no-ops. // //===----------------------------------------------------------------------===// llvm/lib/Support/VersionTuple.cpp //===- VersionTuple.cpp - Version Number Handling ---------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the VersionTuple class, which represents a version in // the form major[.minor[.subminor]]. // //===----------------------------------------------------------------------===// llvm/lib/Support/VirtualFileSystem.cpp //===- VirtualFileSystem.cpp - Virtual File System Layer ------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the VirtualFileSystem interface. // //===----------------------------------------------------------------------===// llvm/lib/Support/Watchdog.cpp //===---- Watchdog.cpp - Implement Watchdog ---------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the Watchdog class. // //===----------------------------------------------------------------------===// llvm/lib/Support/WithColor.cpp //===- WithColor.cpp ------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/YAMLParser.cpp //===- YAMLParser.cpp - Simple YAML parser --------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a YAML parser. // //===----------------------------------------------------------------------===// llvm/lib/Support/YAMLTraits.cpp //===- lib/Support/YAMLTraits.cpp -----------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/Z3Solver.cpp //== Z3Solver.cpp -----------------------------------------------*- C++ -*--==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// llvm/lib/Support/circular_raw_ostream.cpp //===- circular_raw_ostream.cpp - Implement circular_raw_ostream ----------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This implements support for circular buffered streams. // //===----------------------------------------------------------------------===// llvm/lib/Support/raw_os_ostream.cpp //===--- raw_os_ostream.cpp - Implement the raw_os_ostream class ----------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This implements support adapting raw_ostream to std::ostream. // //===----------------------------------------------------------------------===// llvm/lib/Support/raw_ostream.cpp //===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This implements support for bulk buffered stream output. // //===----------------------------------------------------------------------===// llvm/lib/Support/raw_socket_stream.cpp //===-- llvm/Support/raw_socket_stream.cpp - Socket streams --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains raw_ostream implementations for streams to communicate // via UNIX sockets // //===----------------------------------------------------------------------===// llvm/lib/Support/regcomp.c /*- * This code is derived from OpenBSD's libc/regex, original license follows: * * Copyright (c) 1992, 1993, 1994 Henry Spencer. * Copyright (c) 1992, 1993, 1994 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Henry Spencer. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)regcomp.c 8.5 (Berkeley) 3/20/94 */ llvm/lib/Support/regerror.c /*- * This code is derived from OpenBSD's libc/regex, original license follows: * * Copyright (c) 1992, 1993, 1994 Henry Spencer. * Copyright (c) 1992, 1993, 1994 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Henry Spencer. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)regerror.c 8.4 (Berkeley) 3/20/94 */ llvm/lib/Support/regex2.h /*- * This code is derived from OpenBSD's libc/regex, original license follows: * * Copyright (c) 1992, 1993, 1994 Henry Spencer. * Copyright (c) 1992, 1993, 1994 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Henry Spencer. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)regex2.h 8.4 (Berkeley) 3/20/94 */ #ifndef LLVM_SUPPORT_REGEX2_H #define LLVM_SUPPORT_REGEX2_H llvm/lib/Support/regex_impl.h /*- * This code is derived from OpenBSD's libc/regex, original license follows: * * Copyright (c) 1992 Henry Spencer. * Copyright (c) 1992, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Henry Spencer of the University of Toronto. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)regex.h 8.1 (Berkeley) 6/2/93 */ #ifndef LLVM_SUPPORT_REGEX_IMPL_H #define LLVM_SUPPORT_REGEX_IMPL_H llvm/lib/Support/regexec.c /*- * This code is derived from OpenBSD's libc/regex, original license follows: * * Copyright (c) 1992, 1993, 1994 Henry Spencer. * Copyright (c) 1992, 1993, 1994 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Henry Spencer. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)regexec.c 8.3 (Berkeley) 3/20/94 */ /* * the outer shell of llvm_regexec() * * This file includes engine.inc *twice*, after muchos fiddling with the * macros that code uses. This lets the same code operate on two different * representations for state sets. */ llvm/lib/Support/regfree.c /*- * This code is derived from OpenBSD's libc/regex, original license follows: * * Copyright (c) 1992, 1993, 1994 Henry Spencer. * Copyright (c) 1992, 1993, 1994 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Henry Spencer. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)regfree.c 8.3 (Berkeley) 3/20/94 */ llvm/lib/Support/regstrlcpy.c /* * This code is derived from OpenBSD's libc, original license follows: * * Copyright (c) 1998 Todd C. Miller * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ llvm/lib/Support/regutils.h /*- * This code is derived from OpenBSD's libc/regex, original license follows: * * Copyright (c) 1992, 1993, 1994 Henry Spencer. * Copyright (c) 1992, 1993, 1994 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Henry Spencer. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)utils.h 8.3 (Berkeley) 3/20/94 */ #ifndef LLVM_SUPPORT_REGUTILS_H #define LLVM_SUPPORT_REGUTILS_H /* utility definitions */ #define NC (CHAR_MAX - CHAR_MIN + 1) typedef unsigned char uch; /* switch off assertions (if not already off) if no REDEBUG */ #ifndef REDEBUG #ifndef NDEBUG #define NDEBUG /* no assertions please */ #endif #endif llvm/lib/Support/rpmalloc/malloc.c //===------------------------ malloc.c ------------------*- C -*-=============// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This library provides a cross-platform lock free thread caching malloc // implementation in C11. // // // This file provides overrides for the standard library malloc entry points for // C and new/delete operators for C++ It also provides automatic // initialization/finalization of process and threads // //===----------------------------------------------------------------------===// #if defined(__TINYC__) llvm/lib/Support/rpmalloc/rpmalloc.c //===---------------------- rpmalloc.c ------------------*- C -*-=============// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This library provides a cross-platform lock free thread caching malloc // implementation in C11. // //===----------------------------------------------------------------------===// llvm/lib/Support/rpmalloc/rpmalloc.h //===---------------------- rpmalloc.h ------------------*- C -*-=============// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This library provides a cross-platform lock free thread caching malloc // implementation in C11. // //===----------------------------------------------------------------------===// #pragma once llvm/lib/Support/rpmalloc/rpnew.h //===-------------------------- rpnew.h -----------------*- C -*-=============// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This library provides a cross-platform lock free thread caching malloc // implementation in C11. // //===----------------------------------------------------------------------===// #ifdef __cplusplus llvm/lib/Support/xxhash.cpp /* * xxHash - Extremely Fast Hash algorithm * Copyright (C) 2012-2023, Yann Collet * * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following disclaimer * in the documentation and/or other materials provided with the * distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * You can contact the author at : * - xxHash homepage: http://www.xxhash.com * - xxHash source repository : https://github.com/Cyan4973/xxHash */ // xxhash64 is based on commit d2df04efcbef7d7f6886d345861e5dfda4edacc1. Removed // everything but a simple interface for computing xxh64. // xxh3_64bits is based on commit d5891596637d21366b9b1dcf2c0007a3edb26a9e (July // 2023). // xxh3_128bits is based on commit b0adcc54188c3130b1793e7b19c62eb1e669f7df // (June 2024). llvm/lib/Demangle/DLangDemangle.cpp //===--- DLangDemangle.cpp ------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines a demangler for the D programming language as specified /// in the ABI specification, available at: /// https://dlang.org/spec/abi.html#name_mangling /// //===----------------------------------------------------------------------===// llvm/lib/Demangle/Demangle.cpp //===-- Demangle.cpp - Common demangling functions ------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file This file contains definitions of common demangling functions. /// //===----------------------------------------------------------------------===// llvm/lib/Demangle/ItaniumDemangle.cpp //===------------------------- ItaniumDemangle.cpp ------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // FIXME: (possibly) incomplete list of features that clang mangles that this // file does not yet support: // - C++ modules TS llvm/lib/Demangle/MicrosoftDemangle.cpp //===- MicrosoftDemangle.cpp ----------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines a demangler for MSVC-style mangled symbols. // // This file has no dependencies on the rest of LLVM so that it can be // easily reused in other programs such as libcxxabi. // //===----------------------------------------------------------------------===// llvm/lib/Demangle/MicrosoftDemangleNodes.cpp //===- MicrosoftDemangle.cpp ----------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines a demangler for MSVC-style mangled symbols. // //===----------------------------------------------------------------------===// llvm/lib/Demangle/RustDemangle.cpp //===--- RustDemangle.cpp ---------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines a demangler for Rust v0 mangled symbols as specified in // https://rust-lang.github.io/rfcs/2603-rust-symbol-name-mangling-v0.html // //===----------------------------------------------------------------------===// llvm/include/llvm/Support/AArch64BuildAttributes.h //===-- AArch64BuildAttributes.h - AARch64 Build Attributes -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains enumerations and support routines for AArch64 build // attributes as defined in Build Attributes for the AArch64 document. // // Build Attributes for the Arm® 64-bit Architecture (AArch64) 2024Q1 // // https://github.com/ARM-software/abi-aa/pull/230 // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_AARCH64BUILDATTRIBUTES_H #define LLVM_SUPPORT_AARCH64BUILDATTRIBUTES_H llvm/include/llvm/Support/AMDGPUMetadata.h //===--- AMDGPUMetadata.h ---------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // /// \file /// AMDGPU metadata definitions and in-memory representations. /// // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_AMDGPUMETADATA_H #define LLVM_SUPPORT_AMDGPUMETADATA_H llvm/include/llvm/Support/AMDHSAKernelDescriptor.h //===--- AMDHSAKernelDescriptor.h -----------------------------*- C++ -*---===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // /// \file /// AMDHSA kernel descriptor definitions. For more information, visit /// https://llvm.org/docs/AMDGPUUsage.html#kernel-descriptor /// /// \warning /// Any changes to this file should also be audited for corresponding changes /// needed in both the assembler and disassembler, namely: /// * AMDGPUAsmPrinter.{cpp,h} /// * AMDGPUTargetStreamer.{cpp,h} /// * AMDGPUDisassembler.{cpp,h} // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_AMDHSAKERNELDESCRIPTOR_H #define LLVM_SUPPORT_AMDHSAKERNELDESCRIPTOR_H llvm/include/llvm/Support/ARMAttributeParser.h //===- ARMAttributeParser.h - ARM Attribute Information Printer -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ARMATTRIBUTEPARSER_H #define LLVM_SUPPORT_ARMATTRIBUTEPARSER_H llvm/include/llvm/Support/ARMBuildAttributes.h //===-- ARMBuildAttributes.h - ARM Build Attributes -------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains enumerations and support routines for ARM build attributes // as defined in ARM ABI addenda document (ABI release 2.08). // // ELF for the ARM Architecture r2.09 - November 30, 2012 // // http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044e/IHI0044E_aaelf.pdf // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ARMBUILDATTRIBUTES_H #define LLVM_SUPPORT_ARMBUILDATTRIBUTES_H llvm/include/llvm/Support/ARMWinEH.h //===-- llvm/Support/ARMWinEH.h - Windows on ARM EH Constants ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ARMWINEH_H #define LLVM_SUPPORT_ARMWINEH_H llvm/include/llvm/Support/AlignOf.h //===--- AlignOf.h - Portable calculation of type alignment -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the AlignedCharArrayUnion class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ALIGNOF_H #define LLVM_SUPPORT_ALIGNOF_H llvm/include/llvm/Support/Alignment.h //===-- llvm/Support/Alignment.h - Useful alignment functions ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains types to represent alignments. // They are instrumented to guarantee some invariants are preserved and prevent // invalid manipulations. // // - Align represents an alignment in bytes, it is always set and always a valid // power of two, its minimum value is 1 which means no alignment requirements. // // - MaybeAlign is an optional type, it may be undefined or set. When it's set // you can get the underlying Align type by using the value() method. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ALIGNMENT_H_ #define LLVM_SUPPORT_ALIGNMENT_H_ llvm/include/llvm/Support/Allocator.h //===- Allocator.h - Simple memory allocation abstraction -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// /// This file defines the BumpPtrAllocator interface. BumpPtrAllocator conforms /// to the LLVM "Allocator" concept and is similar to MallocAllocator, but /// objects cannot be deallocated. Their lifetime is tied to the lifetime of the /// allocator. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ALLOCATOR_H #define LLVM_SUPPORT_ALLOCATOR_H llvm/include/llvm/Support/AllocatorBase.h //===- AllocatorBase.h - Simple memory allocation abstraction ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// /// This file defines MallocAllocator. MallocAllocator conforms to the LLVM /// "Allocator" concept which consists of an Allocate method accepting a size /// and alignment, and a Deallocate accepting a pointer and size. Further, the /// LLVM "Allocator" concept has overloads of Allocate and Deallocate for /// setting size and alignment based on the final type. These overloads are /// typically provided by a base class template \c AllocatorBase. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ALLOCATORBASE_H #define LLVM_SUPPORT_ALLOCATORBASE_H #ifdef _MSC_VER #define LLVM_ALLOCATORHOLDER_EMPTYBASE __declspec(empty_bases) #else #define LLVM_ALLOCATORHOLDER_EMPTYBASE #endif // _MSC_VER llvm/include/llvm/Support/ArrayRecycler.h //==- llvm/Support/ArrayRecycler.h - Recycling of Arrays ---------*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the ArrayRecycler class template which can recycle small // arrays allocated from one of the allocators in Allocator.h // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ARRAYRECYCLER_H #define LLVM_SUPPORT_ARRAYRECYCLER_H llvm/include/llvm/Support/Atomic.h //===- llvm/Support/Atomic.h - Atomic Operations -----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the llvm::sys atomic operations. // // DO NOT USE IN NEW CODE! // // New code should always rely on the std::atomic facilities in C++11. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ATOMIC_H #define LLVM_SUPPORT_ATOMIC_H llvm/include/llvm/Support/AtomicOrdering.h //===-- llvm/Support/AtomicOrdering.h ---Atomic Ordering---------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// Atomic ordering constants. /// /// These values are used by LLVM to represent atomic ordering for C++11's /// memory model and more, as detailed in docs/Atomics.rst. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ATOMICORDERING_H #define LLVM_SUPPORT_ATOMICORDERING_H llvm/include/llvm/Support/AutoConvert.h /*===- AutoConvert.h - Auto conversion between ASCII/EBCDIC -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains functions used for auto conversion between // ASCII/EBCDIC codepages specific to z/OS. // //===----------------------------------------------------------------------===*/ #ifndef LLVM_SUPPORT_AUTOCONVERT_H #define LLVM_SUPPORT_AUTOCONVERT_H #ifdef __MVS__ llvm/include/llvm/Support/Automaton.h //===-- Automaton.h - Support for driving TableGen-produced DFAs ----------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements class that drive and introspect deterministic finite- // state automata (DFAs) as generated by TableGen's -gen-automata backend. // // For a description of how to define an automaton, see // include/llvm/TableGen/Automaton.td. // // One important detail is that these deterministic automata are created from // (potentially) nondeterministic definitions. Therefore a unique sequence of // input symbols will produce one path through the DFA but multiple paths // through the original NFA. An automaton by default only returns "accepted" or // "not accepted", but frequently we want to analyze what NFA path was taken. // Finding a path through the NFA states that results in a DFA state can help // answer *what* the solution to a problem was, not just that there exists a // solution. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_AUTOMATON_H #define LLVM_SUPPORT_AUTOMATON_H llvm/include/llvm/Support/BCD.h //===- llvm/Support/BCD.h - Binary-Coded Decimal utility functions -*- C++ -*-// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares some utility functions for encoding/decoding BCD values. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BCD_H #define LLVM_SUPPORT_BCD_H llvm/include/llvm/Support/BLAKE3.h //==- BLAKE3.h - BLAKE3 C++ wrapper for LLVM ---------------------*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This is a C++ wrapper of the BLAKE3 C interface. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BLAKE3_H #define LLVM_SUPPORT_BLAKE3_H llvm/include/llvm/Support/BalancedPartitioning.h //===- BalancedPartitioning.h ---------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements BalancedPartitioning, a recursive balanced graph // partitioning algorithm. // // The algorithm is used to find an ordering of FunctionNodes while optimizing // a specified objective. The algorithm uses recursive bisection; it starts // with a collection of unordered FunctionNodes and tries to split them into // two sets (buckets) of equal cardinality. Each bisection step is comprised of // iterations that greedily swap the FunctionNodes between the two buckets while // there is an improvement of the objective. Once the process converges, the // problem is divided into two sub-problems of half the size, which are // recursively applied for the two buckets. The final ordering of the // FunctionNodes is obtained by concatenating the two (recursively computed) // orderings. // // In order to speed up the computation, we limit the depth of the recursive // tree by a specified constant (SplitDepth) and apply at most a constant // number of greedy iterations per split (IterationsPerSplit). The worst-case // time complexity of the implementation is bounded by O(M*log^2 N), where // N is the number of FunctionNodes and M is the number of // FunctionNode-UtilityNode edges; (assuming that any collection of D // FunctionNodes contains O(D) UtilityNodes). Notice that the two different // recursive sub-problems are independent and thus can be efficiently processed // in parallel. // // Reference: // * Optimizing Function Layout for Mobile Applications, // https://arxiv.org/abs/2211.09285 // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BALANCED_PARTITIONING_H #define LLVM_SUPPORT_BALANCED_PARTITIONING_H llvm/include/llvm/Support/Base64.h //===--- Base64.h - Base64 Encoder/Decoder ----------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file provides generic base64 encoder/decoder. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BASE64_H #define LLVM_SUPPORT_BASE64_H llvm/include/llvm/Support/BinaryByteStream.h //===- BinaryByteStream.h ---------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception //===----------------------------------------------------------------------===// // A BinaryStream which stores data in a single continguous memory buffer. //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BINARYBYTESTREAM_H #define LLVM_SUPPORT_BINARYBYTESTREAM_H llvm/include/llvm/Support/BinaryItemStream.h //===- BinaryItemStream.h ---------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BINARYITEMSTREAM_H #define LLVM_SUPPORT_BINARYITEMSTREAM_H llvm/include/llvm/Support/BinaryStream.h //===- BinaryStream.h - Base interface for a stream of data -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BINARYSTREAM_H #define LLVM_SUPPORT_BINARYSTREAM_H llvm/include/llvm/Support/BinaryStreamArray.h //===- BinaryStreamArray.h - Array backed by an arbitrary stream *- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// Lightweight arrays that are backed by an arbitrary BinaryStream. This file /// provides two different array implementations. /// /// VarStreamArray - Arrays of variable length records. The user specifies /// an Extractor type that can extract a record from a given offset and /// return the number of bytes consumed by the record. /// /// FixedStreamArray - Arrays of fixed length records. This is similar in /// spirit to ArrayRef, but since it is backed by a BinaryStream, the /// elements of the array need not be laid out in contiguous memory. /// #ifndef LLVM_SUPPORT_BINARYSTREAMARRAY_H #define LLVM_SUPPORT_BINARYSTREAMARRAY_H llvm/include/llvm/Support/BinaryStreamError.h //===- BinaryStreamError.h - Error extensions for Binary Streams *- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BINARYSTREAMERROR_H #define LLVM_SUPPORT_BINARYSTREAMERROR_H llvm/include/llvm/Support/BinaryStreamReader.h //===- BinaryStreamReader.h - Reads objects from a binary stream *- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BINARYSTREAMREADER_H #define LLVM_SUPPORT_BINARYSTREAMREADER_H llvm/include/llvm/Support/BinaryStreamRef.h //===- BinaryStreamRef.h - A copyable reference to a stream -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BINARYSTREAMREF_H #define LLVM_SUPPORT_BINARYSTREAMREF_H llvm/include/llvm/Support/BinaryStreamWriter.h //===- BinaryStreamWriter.h - Writes objects to a BinaryStream ---*- C++-*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BINARYSTREAMWRITER_H #define LLVM_SUPPORT_BINARYSTREAMWRITER_H llvm/include/llvm/Support/BlockFrequency.h //===-------- BlockFrequency.h - Block Frequency Wrapper --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements Block Frequency class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BLOCKFREQUENCY_H #define LLVM_SUPPORT_BLOCKFREQUENCY_H llvm/include/llvm/Support/BranchProbability.h //===- BranchProbability.h - Branch Probability Wrapper ---------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Definition of BranchProbability shared by IR and Machine Instructions. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BRANCHPROBABILITY_H #define LLVM_SUPPORT_BRANCHPROBABILITY_H llvm/include/llvm/Support/BuryPointer.h //===- llvm/Support/BuryPointer.h - Memory Manipulation/Leak ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_BURYPOINTER_H #define LLVM_SUPPORT_BURYPOINTER_H llvm/include/llvm/Support/CBindingWrapping.h //===- llvm/Support/CBindingWrapping.h - C Interface Wrapping ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the wrapping macros for the C interface. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CBINDINGWRAPPING_H #define LLVM_SUPPORT_CBINDINGWRAPPING_H llvm/include/llvm/Support/CFGDiff.h //===- CFGDiff.h - Define a CFG snapshot. -----------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines specializations of GraphTraits that allows generic // algorithms to see a different snapshot of a CFG. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CFGDIFF_H #define LLVM_SUPPORT_CFGDIFF_H llvm/include/llvm/Support/CFGUpdate.h //===- CFGUpdate.h - Encode a CFG Edge Update. ------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines a CFG Edge Update: Insert or Delete, and two Nodes as the // Edge ends. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CFGUPDATE_H #define LLVM_SUPPORT_CFGUPDATE_H llvm/include/llvm/Support/CRC.h //===-- llvm/Support/CRC.h - Cyclic Redundancy Check-------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains implementations of CRC functions. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CRC_H #define LLVM_SUPPORT_CRC_H llvm/include/llvm/Support/CSKYAttributeParser.h //===---- CSKYAttributeParser.h - CSKY Attribute Parser ---------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CSKYATTRIBUTEPARSER_H #define LLVM_SUPPORT_CSKYATTRIBUTEPARSER_H llvm/include/llvm/Support/CSKYAttributes.h //===---- CSKYAttributes.h - CSKY Attributes --------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains enumerations for CSKY attributes. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CSKYATTRIBUTES_H #define LLVM_SUPPORT_CSKYATTRIBUTES_H llvm/include/llvm/Support/CachePruning.h //=- CachePruning.h - Helper to manage the pruning of a cache dir -*- C++ -*-=// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements pruning of a directory intended for cache storage, using // various policies. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CACHEPRUNING_H #define LLVM_SUPPORT_CACHEPRUNING_H llvm/include/llvm/Support/Caching.h //===- Caching.h - LLVM Local File Cache ------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the CachedFileStream and the localCache function, which // simplifies caching files on the local filesystem in a directory whose // contents are managed by a CachePruningPolicy. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CACHING_H #define LLVM_SUPPORT_CACHING_H llvm/include/llvm/Support/Capacity.h //===--- Capacity.h - Generic computation of ADT memory use -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the capacity function that computes the amount of // memory used by an ADT. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CAPACITY_H #define LLVM_SUPPORT_CAPACITY_H llvm/include/llvm/Support/Casting.h //===- llvm/Support/Casting.h - Allow flexible, checked, casts --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the isa(), cast(), dyn_cast(), // cast_if_present(), and dyn_cast_if_present() templates. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CASTING_H #define LLVM_SUPPORT_CASTING_H llvm/include/llvm/Support/CheckedArithmetic.h //==-- llvm/Support/CheckedArithmetic.h - Safe arithmetical operations *- C++ // // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains generic functions for operating on integers which // give the indication on whether the operation has overflown. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CHECKEDARITHMETIC_H #define LLVM_SUPPORT_CHECKEDARITHMETIC_H llvm/include/llvm/Support/Chrono.h //===- llvm/Support/Chrono.h - Utilities for Timing Manipulation-*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CHRONO_H #define LLVM_SUPPORT_CHRONO_H llvm/include/llvm/Support/CodeGen.h //===-- llvm/Support/CodeGen.h - CodeGen Concepts ---------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file define some types which define code generation concepts. For // example, relocation model. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CODEGEN_H #define LLVM_SUPPORT_CODEGEN_H llvm/include/llvm/Support/CodeGenCoverage.h //== llvm/Support/CodeGenCoverage.h ------------------------------*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file This file provides rule coverage tracking for tablegen-erated CodeGen. //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CODEGENCOVERAGE_H #define LLVM_SUPPORT_CODEGENCOVERAGE_H llvm/include/llvm/Support/CommandLine.h //===- llvm/Support/CommandLine.h - Command line handler --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This class implements a command line argument processor that is useful when // creating a tool. It provides a simple, minimalistic interface that is easily // extensible and supports nonlocal (library) command line options. // // Note that rather than trying to figure out what this code does, you should // read the library documentation located in docs/CommandLine.html or looks at // the many example usages in tools/*/*.cpp // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_COMMANDLINE_H #define LLVM_SUPPORT_COMMANDLINE_H llvm/include/llvm/Support/Compiler.h //===-- llvm/Support/Compiler.h - Compiler abstraction support --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines several macros, based on the current compiler. This allows // use of compiler-specific features in a way that remains portable. This header // can be included from either C or C++. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_COMPILER_H #define LLVM_SUPPORT_COMPILER_H llvm/include/llvm/Support/Compression.h //===-- llvm/Support/Compression.h ---Compression----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains basic functions for compression/decompression. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_COMPRESSION_H #define LLVM_SUPPORT_COMPRESSION_H llvm/include/llvm/Support/ConvertEBCDIC.h //===--- ConvertEBCDIC.h - UTF8/EBCDIC CharSet Conversion -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file provides utility functions for converting between EBCDIC-1047 and /// UTF-8. /// /// //===----------------------------------------------------------------------===// llvm/include/llvm/Support/ConvertUTF.h /*===--- ConvertUTF.h - Universal Character Names conversions ---------------=== * * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * See https://llvm.org/LICENSE.txt for license information. * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * *==------------------------------------------------------------------------==*/ /* * Copyright © 1991-2015 Unicode, Inc. All rights reserved. * Distributed under the Terms of Use in * http://www.unicode.org/copyright.html. * * Permission is hereby granted, free of charge, to any person obtaining * a copy of the Unicode data files and any associated documentation * (the "Data Files") or Unicode software and any associated documentation * (the "Software") to deal in the Data Files or Software * without restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, and/or sell copies of * the Data Files or Software, and to permit persons to whom the Data Files * or Software are furnished to do so, provided that * (a) this copyright and permission notice appear with all copies * of the Data Files or Software, * (b) this copyright and permission notice appear in associated * documentation, and * (c) there is clear notice in each modified Data File or in the Software * as well as in the documentation associated with the Data File(s) or * Software that the data or software has been modified. * * THE DATA FILES AND SOFTWARE ARE 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 OF THIRD PARTY RIGHTS. * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS * NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL * DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THE DATA FILES OR SOFTWARE. * * Except as contained in this notice, the name of a copyright holder * shall not be used in advertising or otherwise to promote the sale, * use or other dealings in these Data Files or Software without prior * written authorization of the copyright holder. */ /* --------------------------------------------------------------------- Conversions between UTF32, UTF-16, and UTF-8. Header file. Several funtions are included here, forming a complete set of conversions between the three formats. UTF-7 is not included here, but is handled in a separate source file. Each of these routines takes pointers to input buffers and output buffers. The input buffers are const. Each routine converts the text between *sourceStart and sourceEnd, putting the result into the buffer between *targetStart and targetEnd. Note: the end pointers are *after* the last item: e.g. *(sourceEnd - 1) is the last item. The return result indicates whether the conversion was successful, and if not, whether the problem was in the source or target buffers. (Only the first encountered problem is indicated.) After the conversion, *sourceStart and *targetStart are both updated to point to the end of last text successfully converted in the respective buffers. Input parameters: sourceStart - pointer to a pointer to the source buffer. The contents of this are modified on return so that it points at the next thing to be converted. targetStart - similarly, pointer to pointer to the target buffer. sourceEnd, targetEnd - respectively pointers to the ends of the two buffers, for overflow checking only. These conversion functions take a ConversionFlags argument. When this flag is set to strict, both irregular sequences and isolated surrogates will cause an error. When the flag is set to lenient, both irregular sequences and isolated surrogates are converted. Whether the flag is strict or lenient, all illegal sequences will cause an error return. This includes sequences such as: , , or in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code must check for illegal sequences. When the flag is set to lenient, characters over 0x10FFFF are converted to the replacement character; otherwise (when the flag is set to strict) they constitute an error. Output parameters: The value "sourceIllegal" is returned from some routines if the input sequence is malformed. When "sourceIllegal" is returned, the source value will point to the illegal value that caused the problem. E.g., in UTF-8 when a sequence is malformed, it points to the start of the malformed sequence. Author: Mark E. Davis, 1994. Rev History: Rick McGowan, fixes & updates May 2001. Fixes & updates, Sept 2001. ------------------------------------------------------------------------ */ #ifndef LLVM_SUPPORT_CONVERTUTF_H #define LLVM_SUPPORT_CONVERTUTF_H llvm/include/llvm/Support/CrashRecoveryContext.h //===--- CrashRecoveryContext.h - Crash Recovery ----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CRASHRECOVERYCONTEXT_H #define LLVM_SUPPORT_CRASHRECOVERYCONTEXT_H llvm/include/llvm/Support/DJB.h //===-- llvm/Support/DJB.h ---DJB Hash --------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains support for the DJ Bernstein hash function. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_DJB_H #define LLVM_SUPPORT_DJB_H llvm/include/llvm/Support/DOTGraphTraits.h //===-- llvm/Support/DOTGraphTraits.h - Customize .dot output ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines a template class that can be used to customize dot output // graphs generated by the GraphWriter.h file. The default implementation of // this file will produce a simple, but not very polished graph. By // specializing this template, lots of customization opportunities are possible. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_DOTGRAPHTRAITS_H #define LLVM_SUPPORT_DOTGRAPHTRAITS_H llvm/include/llvm/Support/DXILABI.h //===-- DXILABI.h - ABI Sensitive Values for DXIL ---------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains definitions of various constants and enums that are // required to remain stable as per the DXIL format's requirements. // // Documentation for DXIL can be found in // https://github.com/Microsoft/DirectXShaderCompiler/blob/main/docs/DXIL.rst. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_DXILABI_H #define LLVM_SUPPORT_DXILABI_H llvm/include/llvm/Support/DataExtractor.h //===-- DataExtractor.h -----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_DATAEXTRACTOR_H #define LLVM_SUPPORT_DATAEXTRACTOR_H llvm/include/llvm/Support/DataTypes.h //===-- llvm/Support/DataTypes.h - Define fixed size types ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Due to layering constraints (Support depends on llvm-c) this is a thin // wrapper around the implementation that lives in llvm-c, though most clients // can/should think of this as being provided by Support for simplicity (not // many clients are aware of their dependency on llvm-c). // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_DATATYPES_H #define LLVM_SUPPORT_DATATYPES_H llvm/include/llvm/Support/Debug.h //===- llvm/Support/Debug.h - Easy way to add debug output ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a handy way of adding debugging information to your // code, without it being enabled all of the time, and without having to add // command line options to enable it. // // In particular, just wrap your code with the LLVM_DEBUG() macro, and it will // be enabled automatically if you specify '-debug' on the command-line. // LLVM_DEBUG() requires the DEBUG_TYPE macro to be defined. Set it to "foo" // specify that your debug code belongs to class "foo". Be careful that you only // do this after including Debug.h and not around any llvm/include/llvm/Support/DebugCounter.h //===- llvm/Support/DebugCounter.h - Debug counter support ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// This file provides an implementation of debug counters. Debug /// counters are a tool that let you narrow down a miscompilation to a specific /// thing happening. /// /// To give a use case: Imagine you have a file, very large, and you /// are trying to understand the minimal transformation that breaks it. Bugpoint /// and bisection is often helpful here in narrowing it down to a specific pass, /// but it's still a very large file, and a very complicated pass to try to /// debug. That is where debug counting steps in. You can instrument the pass /// with a debug counter before it does a certain thing, and depending on the /// counts, it will either execute that thing or not. The debug counter itself /// consists of a list of chunks (inclusive numeric ranges). `shouldExecute` /// returns true iff the list is empty or the current count is in one of the /// chunks. /// /// Note that a counter set to a negative number will always execute. For a /// concrete example, during predicateinfo creation, the renaming pass replaces /// each use with a renamed use. //// /// If I use DEBUG_COUNTER to create a counter called "predicateinfo", and /// variable name RenameCounter, and then instrument this renaming with a debug /// counter, like so: /// /// if (!DebugCounter::shouldExecute(RenameCounter) /// /// /// Now I can, from the command line, make it rename or not rename certain uses /// by setting the chunk list. /// So for example /// bin/opt -debug-counter=predicateinfo=47 /// will skip renaming the first 47 uses, then rename one, then skip the rest. //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_DEBUGCOUNTER_H #define LLVM_SUPPORT_DEBUGCOUNTER_H llvm/include/llvm/Support/Discriminator.h //===---- llvm/Support/Discriminator.h -- Discriminator Utils ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the constants and utility functions for discriminators. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_DISCRIMINATOR_H #define LLVM_SUPPORT_DISCRIMINATOR_H llvm/include/llvm/Support/DivisionByConstantInfo.h //===- llvm/Support/DivisionByConstantInfo.h ---------------------*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// This file implements support for optimizing divisions by a constant /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_DIVISIONBYCONSTANTINFO_H #define LLVM_SUPPORT_DIVISIONBYCONSTANTINFO_H llvm/include/llvm/Support/Duration.h //===--- Duration.h - wrapper around std::chrono::Duration ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // The sole purpose of this file is to avoid the dependency on in // raw_ostream. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_DURATION_H #define LLVM_SUPPORT_DURATION_H llvm/include/llvm/Support/DynamicLibrary.h //===-- llvm/Support/DynamicLibrary.h - Portable Dynamic Library -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the sys::DynamicLibrary class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_DYNAMICLIBRARY_H #define LLVM_SUPPORT_DYNAMICLIBRARY_H llvm/include/llvm/Support/ELFAttributeParser.h //===- ELF AttributeParser.h - ELF Attribute Parser -------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ELFATTRIBUTEPARSER_H #define LLVM_SUPPORT_ELFATTRIBUTEPARSER_H llvm/include/llvm/Support/ELFAttributes.h //===-- ELFAttributes.h - ELF Attributes ------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ELFATTRIBUTES_H #define LLVM_SUPPORT_ELFATTRIBUTES_H llvm/include/llvm/Support/Endian.h //===- Endian.h - Utilities for IO with endian specific data ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares generic functions to read and write endian specific data. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ENDIAN_H #define LLVM_SUPPORT_ENDIAN_H llvm/include/llvm/Support/EndianStream.h //===- EndianStream.h - Stream ops with endian specific data ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines utilities for operating on streams that have endian // specific data. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ENDIANSTREAM_H #define LLVM_SUPPORT_ENDIANSTREAM_H llvm/include/llvm/Support/Errc.h //===- llvm/Support/Errc.h - Defines the llvm::errc enum --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // While std::error_code works OK on all platforms we use, there are some // some problems with std::errc that can be avoided by using our own // enumeration: // // * std::errc is a namespace in some implementations. That means that ADL // doesn't work and it is sometimes necessary to write std::make_error_code // or in templates: // using std::make_error_code; // make_error_code(...); // // with this enum it is safe to always just use make_error_code. // // * Some implementations define fewer names than others. This header has // the intersection of all the ones we support. // // * std::errc is just marked with is_error_condition_enum. This means that // common patterns like AnErrorCode == errc::no_such_file_or_directory take // 4 virtual calls instead of two comparisons. //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ERRC_H #define LLVM_SUPPORT_ERRC_H llvm/include/llvm/Support/Errno.h //===- llvm/Support/Errno.h - Portable+convenient errno handling -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares some portable and convenient functions to deal with errno. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ERRNO_H #define LLVM_SUPPORT_ERRNO_H llvm/include/llvm/Support/Error.h //===- llvm/Support/Error.h - Recoverable error handling --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines an API used to report recoverable errors. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ERROR_H #define LLVM_SUPPORT_ERROR_H llvm/include/llvm/Support/ErrorHandling.h //===- llvm/Support/ErrorHandling.h - Fatal error handling ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines an API used to indicate fatal error conditions. Non-fatal // errors (most of them) should be handled through LLVMContext. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ERRORHANDLING_H #define LLVM_SUPPORT_ERRORHANDLING_H llvm/include/llvm/Support/ErrorOr.h //===- llvm/Support/ErrorOr.h - Error Smart Pointer -------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// /// Provides ErrorOr smart pointer. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ERROROR_H #define LLVM_SUPPORT_ERROROR_H llvm/include/llvm/Support/ExitCodes.h //===-- llvm/Support/ExitCodes.h - Exit codes for exit() -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file contains definitions of exit codes for exit() function. They are /// either defined by sysexits.h if it is supported, or defined here if /// sysexits.h is not supported. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_EXITCODES_H #define LLVM_SUPPORT_EXITCODES_H llvm/include/llvm/Support/ExponentialBackoff.h //===- llvm/Support/ExponentialBackoff.h ------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines a helper class for implementing exponential backoff. // //===----------------------------------------------------------------------===// #ifndef LLVM_EXPONENTIALBACKOFF_H #define LLVM_EXPONENTIALBACKOFF_H llvm/include/llvm/Support/FileCollector.h //===-- FileCollector.h -----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FILECOLLECTOR_H #define LLVM_SUPPORT_FILECOLLECTOR_H llvm/include/llvm/Support/FileOutputBuffer.h //=== FileOutputBuffer.h - File Output Buffer -------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Utility for creating a in-memory buffer that will be written to a file. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FILEOUTPUTBUFFER_H #define LLVM_SUPPORT_FILEOUTPUTBUFFER_H llvm/include/llvm/Support/FileSystem/UniqueID.h //===- llvm/Support/FileSystem/UniqueID.h - UniqueID for files --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is cut out of llvm/Support/FileSystem.h to allow UniqueID to be // reused without bloating the includes. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FILESYSTEM_UNIQUEID_H #define LLVM_SUPPORT_FILESYSTEM_UNIQUEID_H llvm/include/llvm/Support/FileSystem.h //===- llvm/Support/FileSystem.h - File System OS Concept -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the llvm::sys::fs namespace. It is designed after // TR2/boost filesystem (v3), but modified to remove exception handling and the // path class. // // All functions return an error_code and their actual work via the last out // argument. The out argument is defined if and only if errc::success is // returned. A function may return any error code in the generic or system // category. However, they shall be equivalent to any error conditions listed // in each functions respective documentation if the condition applies. [ note: // this does not guarantee that error_code will be in the set of explicitly // listed codes, but it does guarantee that if any of the explicitly listed // errors occur, the correct error_code will be used ]. All functions may // return errc::not_enough_memory if there is not enough memory to complete the // operation. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FILESYSTEM_H #define LLVM_SUPPORT_FILESYSTEM_H llvm/include/llvm/Support/FileUtilities.h //===- llvm/Support/FileUtilities.h - File System Utilities -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines a family of utility functions which are useful for doing // various things with files. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FILEUTILITIES_H #define LLVM_SUPPORT_FILEUTILITIES_H llvm/include/llvm/Support/Format.h //===- Format.h - Efficient printf-style formatting for streams -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the format() function, which can be used with other // LLVM subsystems to provide printf-style formatting. This gives all the power // and risk of printf. This can be used like this (with raw_ostreams as an // example): // // OS << "mynumber: " << format("%4.5f", 1234.412) << '\n'; // // Or if you prefer: // // OS << format("mynumber: %4.5f\n", 1234.412); // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FORMAT_H #define LLVM_SUPPORT_FORMAT_H llvm/include/llvm/Support/FormatAdapters.h //===- FormatAdapters.h - Formatters for common LLVM types -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FORMATADAPTERS_H #define LLVM_SUPPORT_FORMATADAPTERS_H llvm/include/llvm/Support/FormatCommon.h //===- FormatCommon.h - Formatters for common LLVM types --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FORMATCOMMON_H #define LLVM_SUPPORT_FORMATCOMMON_H llvm/include/llvm/Support/FormatProviders.h //===- FormatProviders.h - Formatters for common LLVM types -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements format providers for many common LLVM types, for example // allowing precision and width specifiers for scalar and string types. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FORMATPROVIDERS_H #define LLVM_SUPPORT_FORMATPROVIDERS_H llvm/include/llvm/Support/FormatVariadic.h //===- FormatVariadic.h - Efficient type-safe string formatting --*- C++-*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the formatv() function which can be used with other LLVM // subsystems to provide printf-like formatting, but with improved safety and // flexibility. The result of `formatv` is an object which can be streamed to // a raw_ostream or converted to a std::string or llvm::SmallString. // // // Convert to std::string. // std::string S = formatv("{0} {1}", 1234.412, "test").str(); // // // Convert to llvm::SmallString // SmallString<8> S = formatv("{0} {1}", 1234.412, "test").sstr<8>(); // // // Stream to an existing raw_ostream. // OS << formatv("{0} {1}", 1234.412, "test"); // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FORMATVARIADIC_H #define LLVM_SUPPORT_FORMATVARIADIC_H llvm/include/llvm/Support/FormatVariadicDetails.h //===- FormatVariadicDetails.h - Helpers for FormatVariadic.h ----*- C++-*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FORMATVARIADICDETAILS_H #define LLVM_SUPPORT_FORMATVARIADICDETAILS_H llvm/include/llvm/Support/FormattedStream.h //===-- llvm/Support/FormattedStream.h - Formatted streams ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains raw_ostream implementations for streams to do // things like pretty-print comments. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_FORMATTEDSTREAM_H #define LLVM_SUPPORT_FORMATTEDSTREAM_H llvm/include/llvm/Support/GenericDomTree.h //===- GenericDomTree.h - Generic dominator trees for graphs ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// /// This file defines a set of templates that efficiently compute a dominator /// tree over a generic graph. This is used typically in LLVM for fast /// dominance queries on the CFG, but is fully generic w.r.t. the underlying /// graph types. /// /// Unlike ADT/* graph algorithms, generic dominator tree has more requirements /// on the graph's NodeRef. The NodeRef should be a pointer and, /// either NodeRef->getParent() must return the parent node that is also a /// pointer or DomTreeNodeTraits needs to be specialized. /// /// FIXME: Maybe GenericDomTree needs a TreeTraits, instead of GraphTraits. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_GENERICDOMTREE_H #define LLVM_SUPPORT_GENERICDOMTREE_H llvm/include/llvm/Support/GenericDomTreeConstruction.h //===- GenericDomTreeConstruction.h - Dominator Calculation ------*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// /// Generic dominator tree construction - this file provides routines to /// construct immediate dominator information for a flow-graph based on the /// Semi-NCA algorithm described in this dissertation: /// /// [1] Linear-Time Algorithms for Dominators and Related Problems /// Loukas Georgiadis, Princeton University, November 2005, pp. 21-23: /// ftp://ftp.cs.princeton.edu/reports/2005/737.pdf /// /// Semi-NCA algorithm runs in O(n^2) worst-case time but usually slightly /// faster than Simple Lengauer-Tarjan in practice. /// /// O(n^2) worst cases happen when the computation of nearest common ancestors /// requires O(n) average time, which is very unlikely in real world. If this /// ever turns out to be an issue, consider implementing a hybrid algorithm /// that uses SLT to perform full constructions and SemiNCA for incremental /// updates. /// /// The file uses the Depth Based Search algorithm to perform incremental /// updates (insertion and deletions). The implemented algorithm is based on /// this publication: /// /// [2] An Experimental Study of Dynamic Dominators /// Loukas Georgiadis, et al., April 12 2016, pp. 5-7, 9-10: /// https://arxiv.org/pdf/1604.02711.pdf /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_GENERICDOMTREECONSTRUCTION_H #define LLVM_SUPPORT_GENERICDOMTREECONSTRUCTION_H llvm/include/llvm/Support/GenericIteratedDominanceFrontier.h //===- IteratedDominanceFrontier.h - Calculate IDF --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// Compute iterated dominance frontiers using a linear time algorithm. /// /// The algorithm used here is based on: /// /// Sreedhar and Gao. A linear time algorithm for placing phi-nodes. /// In Proceedings of the 22nd ACM SIGPLAN-SIGACT Symposium on Principles of /// Programming Languages /// POPL '95. ACM, New York, NY, 62-73. /// /// It has been modified to not explicitly use the DJ graph data structure and /// to directly compute pruned SSA using per-variable liveness information. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_GENERICITERATEDDOMINANCEFRONTIER_H #define LLVM_SUPPORT_GENERICITERATEDDOMINANCEFRONTIER_H llvm/include/llvm/Support/GenericLoopInfo.h //===- GenericLoopInfo - Generic Loop Info for graphs -----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the LoopInfoBase class that is used to identify natural // loops and determine the loop depth of various nodes in a generic graph of // blocks. A natural loop has exactly one entry-point, which is called the // header. Note that natural loops may actually be several loops that share the // same header node. // // This analysis calculates the nesting structure of loops in a function. For // each natural loop identified, this analysis identifies natural loops // contained entirely within the loop and the basic blocks that make up the // loop. // // It can calculate on the fly various bits of information, for example: // // * whether there is a preheader for the loop // * the number of back edges to the header // * whether or not a particular block branches out of the loop // * the successor blocks of the loop // * the loop depth // * etc... // // Note that this analysis specifically identifies *Loops* not cycles or SCCs // in the graph. There can be strongly connected components in the graph which // this analysis will not recognize and that will not be represented by a Loop // instance. In particular, a Loop might be inside such a non-loop SCC, or a // non-loop SCC might contain a sub-SCC which is a Loop. // // For an overview of terminology used in this API (and thus all of our loop // analyses or transforms), see docs/LoopTerminology.rst. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_GENERICLOOPINFO_H #define LLVM_SUPPORT_GENERICLOOPINFO_H llvm/include/llvm/Support/GenericLoopInfoImpl.h //===- GenericLoopInfoImp.h - Generic Loop Info Implementation --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This fle contains the implementation of GenericLoopInfo. It should only be // included in files that explicitly instantiate a GenericLoopInfo. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_GENERICLOOPINFOIMPL_H #define LLVM_SUPPORT_GENERICLOOPINFOIMPL_H llvm/include/llvm/Support/GlobPattern.h //===-- GlobPattern.h - glob pattern matcher implementation -*- C++ -*-----===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a glob pattern matcher. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_GLOBPATTERN_H #define LLVM_SUPPORT_GLOBPATTERN_H llvm/include/llvm/Support/GraphWriter.h //===- llvm/Support/GraphWriter.h - Write graph to a .dot file --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines a simple interface that can be used to print out generic // LLVM graphs to ".dot" files. "dot" is a tool that is part of the AT&T // graphviz package (http://www.research.att.com/sw/tools/graphviz/) which can // be used to turn the files output by this interface into a variety of // different graphics formats. // // Graphs do not need to implement any interface past what is already required // by the GraphTraits template, but they can choose to implement specializations // of the DOTGraphTraits template if they want to customize the graphs output in // any way. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_GRAPHWRITER_H #define LLVM_SUPPORT_GRAPHWRITER_H llvm/include/llvm/Support/HashBuilder.h //===- llvm/Support/HashBuilder.h - Convenient hashing interface-*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements an interface allowing to conveniently build hashes of // various data types, without relying on the underlying hasher type to know // about hashed data types. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_HASHBUILDER_H #define LLVM_SUPPORT_HASHBUILDER_H llvm/include/llvm/Support/HexagonAttributeParser.h //===-- HexagonAttributeParser.h - Hexagon Attribute Parser -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_HEXAGONATTRIBUTEPARSER_H #define LLVM_SUPPORT_HEXAGONATTRIBUTEPARSER_H llvm/include/llvm/Support/HexagonAttributes.h //===-- HexagonAttributes.h - Qualcomm Hexagon Attributes -----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_HEXAGONATTRIBUTES_H #define LLVM_SUPPORT_HEXAGONATTRIBUTES_H llvm/include/llvm/Support/InitLLVM.h //===- InitLLVM.h -----------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_INITLLVM_H #define LLVM_SUPPORT_INITLLVM_H llvm/include/llvm/Support/InstructionCost.h //===- InstructionCost.h ----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// This file defines an InstructionCost class that is used when calculating /// the cost of an instruction, or a group of instructions. In addition to a /// numeric value representing the cost the class also contains a state that /// can be used to encode particular properties, such as a cost being invalid. /// Operations on InstructionCost implement saturation arithmetic, so that /// accumulating costs on large cost-values don't overflow. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_INSTRUCTIONCOST_H #define LLVM_SUPPORT_INSTRUCTIONCOST_H llvm/include/llvm/Support/JSON.h //===--- JSON.h - JSON values, parsing and serialization -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===---------------------------------------------------------------------===// /// /// \file /// This file supports working with JSON data. /// /// It comprises: /// /// - classes which hold dynamically-typed parsed JSON structures /// These are value types that can be composed, inspected, and modified. /// See json::Value, and the related types json::Object and json::Array. /// /// - functions to parse JSON text into Values, and to serialize Values to text. /// See parse(), operator<<, and format_provider. /// /// - a convention and helpers for mapping between json::Value and user-defined /// types. See fromJSON(), ObjectMapper, and the class comment on Value. /// /// - an output API json::OStream which can emit JSON without materializing /// all structures as json::Value. /// /// Typically, JSON data would be read from an external source, parsed into /// a Value, and then converted into some native data structure before doing /// real work on it. (And vice versa when writing). /// /// Other serialization mechanisms you may consider: /// /// - YAML is also text-based, and more human-readable than JSON. It's a more /// complex format and data model, and YAML parsers aren't ubiquitous. /// YAMLParser.h is a streaming parser suitable for parsing large documents /// (including JSON, as YAML is a superset). It can be awkward to use /// directly. YAML I/O (YAMLTraits.h) provides data mapping that is more /// declarative than the toJSON/fromJSON conventions here. /// /// - LLVM bitstream is a space- and CPU- efficient binary format. Typically it /// encodes LLVM IR ("bitcode"), but it can be a container for other data. /// Low-level reader/writer libraries are in Bitstream/Bitstream*.h /// //===---------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_JSON_H #define LLVM_SUPPORT_JSON_H llvm/include/llvm/Support/KnownBits.h //===- llvm/Support/KnownBits.h - Stores known zeros/ones -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains a class for representing known zeros and ones used by // computeKnownBits. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_KNOWNBITS_H #define LLVM_SUPPORT_KNOWNBITS_H llvm/include/llvm/Support/LEB128.h //===- llvm/Support/LEB128.h - [SU]LEB128 utility functions -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares some utility functions for encoding SLEB128 and // ULEB128 values. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_LEB128_H #define LLVM_SUPPORT_LEB128_H llvm/include/llvm/Support/LineIterator.h //===- LineIterator.h - Iterator to read a text buffer's lines --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_LINEITERATOR_H #define LLVM_SUPPORT_LINEITERATOR_H llvm/include/llvm/Support/LockFileManager.h //===--- LockFileManager.h - File-level locking utility ---------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_LOCKFILEMANAGER_H #define LLVM_SUPPORT_LOCKFILEMANAGER_H llvm/include/llvm/Support/LogicalResult.h //===- LogicalResult.h - Utilities for handling success/failure -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_LOGICALRESULT_H #define LLVM_SUPPORT_LOGICALRESULT_H llvm/include/llvm/Support/MD5.h /* -*- C++ -*- * This code is derived from (original license follows): * * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. * MD5 Message-Digest Algorithm (RFC 1321). * * Homepage: * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 * * Author: * Alexander Peslyak, better known as Solar Designer * * This software was written by Alexander Peslyak in 2001. No copyright is * claimed, and the software is hereby placed in the public domain. * In case this attempt to disclaim copyright and place the software in the * public domain is deemed null and void, then the software is * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the * general public under the following terms: * * Redistribution and use in source and binary forms, with or without * modification, are permitted. * * There's ABSOLUTELY NO WARRANTY, express or implied. * * See md5.c for more information. */ #ifndef LLVM_SUPPORT_MD5_H #define LLVM_SUPPORT_MD5_H llvm/include/llvm/Support/MSP430AttributeParser.h //===-- MSP430AttributeParser.h - MSP430 Attribute Parser -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file contains support routines for parsing MSP430 ELF build attributes. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_MSP430ATTRIBUTEPARSER_H #define LLVM_SUPPORT_MSP430ATTRIBUTEPARSER_H llvm/include/llvm/Support/MSP430Attributes.h //===-- MSP430Attributes.h - MSP430 Attributes ------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===-----------------------------------------------------------------------===// /// /// \file /// This file contains enumerations for MSP430 ELF build attributes as /// defined in the MSP430 ELF psABI specification. /// /// MSP430 ELF psABI specification /// /// https://www.ti.com/lit/pdf/slaa534 /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_MSP430ATTRIBUTES_H #define LLVM_SUPPORT_MSP430ATTRIBUTES_H llvm/include/llvm/Support/MSVCErrorWorkarounds.h //===--- MSVCErrorWorkarounds.h - Enable future in MSVC --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // MSVC's promise/future implementation requires types to be default // constructible, so this header provides analogues of Error an Expected // that are default constructed in a safely destructible state. // // FIXME: Kill off this header and migrate all users to Error/Expected once we // move to MSVC versions that support non-default-constructible types. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_MSVCERRORWORKAROUNDS_H #define LLVM_SUPPORT_MSVCERRORWORKAROUNDS_H llvm/include/llvm/Support/ManagedStatic.h //===-- llvm/Support/ManagedStatic.h - Static Global wrapper ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the ManagedStatic class and the llvm_shutdown() function. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_MANAGEDSTATIC_H #define LLVM_SUPPORT_MANAGEDSTATIC_H llvm/include/llvm/Support/MathExtras.h //===-- llvm/Support/MathExtras.h - Useful math functions -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains some functions that are useful for math stuff. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_MATHEXTRAS_H #define LLVM_SUPPORT_MATHEXTRAS_H llvm/include/llvm/Support/MemAlloc.h //===- MemAlloc.h - Memory allocation functions -----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// /// This file defines counterparts of C library allocation functions defined in /// the namespace 'std'. The new allocation functions crash on allocation /// failure instead of returning null pointer. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_MEMALLOC_H #define LLVM_SUPPORT_MEMALLOC_H llvm/include/llvm/Support/Memory.h //===- llvm/Support/Memory.h - Memory Support -------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the llvm::sys::Memory class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_MEMORY_H #define LLVM_SUPPORT_MEMORY_H llvm/include/llvm/Support/MemoryBuffer.h //===--- MemoryBuffer.h - Memory Buffer Interface ---------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the MemoryBuffer interface. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_MEMORYBUFFER_H #define LLVM_SUPPORT_MEMORYBUFFER_H llvm/include/llvm/Support/MemoryBufferRef.h //===- MemoryBufferRef.h - Memory Buffer Reference --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the MemoryBuffer interface. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_MEMORYBUFFERREF_H #define LLVM_SUPPORT_MEMORYBUFFERREF_H llvm/include/llvm/Support/ModRef.h //===--- ModRef.h - Memory effect modeling ----------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Definitions of ModRefInfo and MemoryEffects, which are used to // describe the memory effects of instructions. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_MODREF_H #define LLVM_SUPPORT_MODREF_H llvm/include/llvm/Support/Mutex.h //===- llvm/Support/Mutex.h - Mutex Operating System Concept -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the llvm::sys::Mutex class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_MUTEX_H #define LLVM_SUPPORT_MUTEX_H llvm/include/llvm/Support/NativeFormatting.h //===- NativeFormatting.h - Low level formatting helpers ---------*- C++-*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_NATIVEFORMATTING_H #define LLVM_SUPPORT_NATIVEFORMATTING_H llvm/include/llvm/Support/OnDiskHashTable.h //===--- OnDiskHashTable.h - On-Disk Hash Table Implementation --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// Defines facilities for reading and writing on-disk hash tables. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ONDISKHASHTABLE_H #define LLVM_SUPPORT_ONDISKHASHTABLE_H llvm/include/llvm/Support/OptimizedStructLayout.h //===-- OptimizedStructLayout.h - Struct layout algorithm ---------*- C++ -*-=// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file provides an interface for laying out a sequence of fields /// as a struct in a way that attempts to minimizes the total space /// requirements of the struct while still satisfying the layout /// requirements of the individual fields. The resulting layout may be /// substantially more compact than simply laying out the fields in their /// original order. /// /// Fields may be pre-assigned fixed offsets. They may also be given sizes /// that are not multiples of their alignments. There is no currently no /// way to describe that a field has interior padding that other fields may /// be allocated into. /// /// This algorithm does not claim to be "optimal" for several reasons: /// /// - First, it does not guarantee that the result is minimal in size. /// There is no known efficient algoorithm to achieve minimality for /// unrestricted inputs. Nonetheless, this algorithm /// /// - Second, there are other ways that a struct layout could be optimized /// besides space usage, such as locality. This layout may have a mixed /// impact on locality: less overall memory may be used, but adjacent /// fields in the original array may be moved further from one another. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_OPTIMIZEDSTRUCTLAYOUT_H #define LLVM_SUPPORT_OPTIMIZEDSTRUCTLAYOUT_H llvm/include/llvm/Support/OptionStrCmp.h //===- OptionStrCmp.h - Option String Comparison ----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_OPTIONSTRCMP_H #define LLVM_SUPPORT_OPTIONSTRCMP_H llvm/include/llvm/Support/PGOOptions.h //===------ PGOOptions.h -- PGO option tunables ----------------*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// /// Define option tunables for PGO. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_PGOOPTIONS_H #define LLVM_SUPPORT_PGOOPTIONS_H llvm/include/llvm/Support/Parallel.h //===- llvm/Support/Parallel.h - Parallel algorithms ----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_PARALLEL_H #define LLVM_SUPPORT_PARALLEL_H llvm/include/llvm/Support/Path.h //===- llvm/Support/Path.h - Path Operating System Concept ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the llvm::sys::path namespace. It is designed after // TR2/boost filesystem (v3), but modified to remove exception handling and the // path class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_PATH_H #define LLVM_SUPPORT_PATH_H llvm/include/llvm/Support/PerThreadBumpPtrAllocator.h //===- PerThreadBumpPtrAllocator.h ------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_PERTHREADBUMPPTRALLOCATOR_H #define LLVM_SUPPORT_PERTHREADBUMPPTRALLOCATOR_H llvm/include/llvm/Support/PluginLoader.h //===-- llvm/Support/PluginLoader.h - Plugin Loader for Tools ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // A tool can llvm/include/llvm/Support/PointerLikeTypeTraits.h //===- llvm/Support/PointerLikeTypeTraits.h - Pointer Traits ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the PointerLikeTypeTraits class. This allows data // structures to reason about pointers and other things that are pointer sized. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_POINTERLIKETYPETRAITS_H #define LLVM_SUPPORT_POINTERLIKETYPETRAITS_H llvm/include/llvm/Support/PrettyStackTrace.h //===- llvm/Support/PrettyStackTrace.h - Pretty Crash Handling --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the PrettyStackTraceEntry class, which is used to make // crashes give more contextual information about what the program was doing // when it crashed. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_PRETTYSTACKTRACE_H #define LLVM_SUPPORT_PRETTYSTACKTRACE_H llvm/include/llvm/Support/Printable.h //===--- Printable.h - Print function helpers -------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the Printable struct. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_PRINTABLE_H #define LLVM_SUPPORT_PRINTABLE_H llvm/include/llvm/Support/Process.h //===- llvm/Support/Process.h -----------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// /// Provides a library for accessing information about this process and other /// processes on the operating system. Also provides means of spawning /// subprocess for commands. The design of this library is modeled after the /// proposed design of the Boost.Process library, and is design specifically to /// follow the style of standard libraries and potentially become a proposal /// for a standard library. /// /// This file declares the llvm::sys::Process class which contains a collection /// of legacy static interfaces for extracting various information about the /// current process. The goal is to migrate users of this API over to the new /// interfaces. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_PROCESS_H #define LLVM_SUPPORT_PROCESS_H llvm/include/llvm/Support/Program.h //===- llvm/Support/Program.h ------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the llvm::sys::Program class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_PROGRAM_H #define LLVM_SUPPORT_PROGRAM_H llvm/include/llvm/Support/RISCVAttributeParser.h //===-- RISCVAttributeParser.h - RISCV Attribute Parser ---------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_RISCVATTRIBUTEPARSER_H #define LLVM_SUPPORT_RISCVATTRIBUTEPARSER_H llvm/include/llvm/Support/RISCVAttributes.h //===-- RISCVAttributes.h - RISCV Attributes --------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains enumerations for RISCV attributes as defined in RISC-V // ELF psABI specification. // // RISC-V ELF psABI specification // // https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_RISCVATTRIBUTES_H #define LLVM_SUPPORT_RISCVATTRIBUTES_H llvm/include/llvm/Support/RISCVISAUtils.h //===-- RISCVISAUtils.h - RISC-V ISA Utilities ------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Utilities shared by TableGen and RISCVISAInfo. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_RISCVISAUTILS_H #define LLVM_SUPPORT_RISCVISAUTILS_H llvm/include/llvm/Support/RWMutex.h //===- RWMutex.h - Reader/Writer Mutual Exclusion Lock ----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the llvm::sys::RWMutex class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_RWMUTEX_H #define LLVM_SUPPORT_RWMUTEX_H llvm/include/llvm/Support/RandomNumberGenerator.h //==- llvm/Support/RandomNumberGenerator.h - RNG for diversity ---*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines an abstraction for deterministic random number // generation (RNG). Note that the current implementation is not // cryptographically secure as it uses the C++11 facilities. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_RANDOMNUMBERGENERATOR_H_ #define LLVM_SUPPORT_RANDOMNUMBERGENERATOR_H_ llvm/include/llvm/Support/Recycler.h //==- llvm/Support/Recycler.h - Recycling Allocator --------------*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the Recycler class template. See the doxygen comment for // Recycler for more details. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_RECYCLER_H #define LLVM_SUPPORT_RECYCLER_H llvm/include/llvm/Support/RecyclingAllocator.h //==- llvm/Support/RecyclingAllocator.h - Recycling Allocator ----*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the RecyclingAllocator class. See the doxygen comment for // RecyclingAllocator for more details on the implementation. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_RECYCLINGALLOCATOR_H #define LLVM_SUPPORT_RECYCLINGALLOCATOR_H llvm/include/llvm/Support/Regex.h //===-- Regex.h - Regular Expression matcher implementation -*- C++ -*-----===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements a POSIX regular expression matcher. Both Basic and // Extended POSIX regular expressions (ERE) are supported. EREs were extended // to support backreferences in matches. // This implementation also supports matching strings with embedded NUL chars. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_REGEX_H #define LLVM_SUPPORT_REGEX_H llvm/include/llvm/Support/Registry.h //=== Registry.h - Linker-supported plugin registries -----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Defines a registry template for discovering pluggable modules. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_REGISTRY_H #define LLVM_SUPPORT_REGISTRY_H llvm/include/llvm/Support/SHA1.h //==- SHA1.h - SHA1 implementation for LLVM --*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // This code is taken from public domain // (http://oauth.googlecode.com/svn/code/c/liboauth/src/sha1.c) // and modified by wrapping it in a C++ interface for LLVM, // and removing unnecessary code. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SHA1_H #define LLVM_SUPPORT_SHA1_H llvm/include/llvm/Support/SHA256.h //====- SHA256.cpp - SHA256 implementation ---*- C++ -* ======// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /* * The SHA-256 Secure Hash Standard was published by NIST in 2002. * * http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf * * The implementation is based on nacl's sha256 implementation [0] and LLVM's * pre-exsiting SHA1 code [1]. * * [0] https://hyperelliptic.org/nacl/nacl-20110221.tar.bz2 (public domain * code) * [1] llvm/lib/Support/SHA1.{h,cpp} */ //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SHA256_H #define LLVM_SUPPORT_SHA256_H llvm/include/llvm/Support/SMLoc.h //===- SMLoc.h - Source location for use with diagnostics -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the SMLoc class. This class encapsulates a location in // source code for use in diagnostics. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SMLOC_H #define LLVM_SUPPORT_SMLOC_H llvm/include/llvm/Support/SMTAPI.h //===- SMTAPI.h -------------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines a SMT generic Solver API, which will be the base class // for every SMT solver specific class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SMTAPI_H #define LLVM_SUPPORT_SMTAPI_H llvm/include/llvm/Support/SaveAndRestore.h //===-- SaveAndRestore.h - Utility -------------------------------*- C++ -*-=// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file provides utility classes that use RAII to save and restore /// values. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SAVEANDRESTORE_H #define LLVM_SUPPORT_SAVEANDRESTORE_H llvm/include/llvm/Support/ScaledNumber.h //===- llvm/Support/ScaledNumber.h - Support for scaled numbers -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains functions (and a class) useful for working with scaled // numbers -- in particular, pairs of integers where one represents digits and // another represents a scale. The functions are helpers and live in the // namespace ScaledNumbers. The class ScaledNumber is useful for modelling // certain cost metrics that need simple, integer-like semantics that are easy // to reason about. // // These might remind you of soft-floats. If you want one of those, you're in // the wrong place. Look at include/llvm/ADT/APFloat.h instead. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SCALEDNUMBER_H #define LLVM_SUPPORT_SCALEDNUMBER_H llvm/include/llvm/Support/ScopedPrinter.h //===-- ScopedPrinter.h ----------------------------------------*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SCOPEDPRINTER_H #define LLVM_SUPPORT_SCOPEDPRINTER_H llvm/include/llvm/Support/Signals.h //===- llvm/Support/Signals.h - Signal Handling support ----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines some helpful functions for dealing with the possibility of // unix signals occurring while your program is running. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SIGNALS_H #define LLVM_SUPPORT_SIGNALS_H llvm/include/llvm/Support/Signposts.h //===-- llvm/Support/Signposts.h - Interval debug annotations ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // /// \file Some OS's provide profilers that allow applications to provide custom /// annotations to the profiler. For example, on Xcode 10 and later 'signposts' /// can be emitted by the application and these will be rendered to the Points /// of Interest track on the instruments timeline. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SIGNPOSTS_H #define LLVM_SUPPORT_SIGNPOSTS_H llvm/include/llvm/Support/SipHash.h //===--- SipHash.h - An ABI-stable string SipHash ---------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // An implementation of SipHash, a hash function optimized for speed on // short inputs. Based on the SipHash reference implementation. // // Also provides one specific wrapper on top of SipHash-2-4-64 to compute // compute ABI-stable ptrauth discriminators. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SIPHASH_H #define LLVM_SUPPORT_SIPHASH_H llvm/include/llvm/Support/SmallVectorMemoryBuffer.h //===- SmallVectorMemoryBuffer.h --------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares a wrapper class to hold the memory into which an // object will be generated. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SMALLVECTORMEMORYBUFFER_H #define LLVM_SUPPORT_SMALLVECTORMEMORYBUFFER_H llvm/include/llvm/Support/Solaris/sys/regset.h /*===- llvm/Support/Solaris/sys/regset.h ------------------------*- C++ -*-===* * * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * See https://llvm.org/LICENSE.txt for license information. * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * *===----------------------------------------------------------------------===* * * This file works around excessive name space pollution from the system header * on Solaris hosts. * *===----------------------------------------------------------------------===*/ #ifndef LLVM_SUPPORT_SOLARIS_SYS_REGSET_H llvm/include/llvm/Support/SourceMgr.h //===- SourceMgr.h - Manager for Source Buffers & Diagnostics ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the SMDiagnostic and SourceMgr classes. This // provides a simple substrate for diagnostics, llvm/include/llvm/Support/SpecialCaseList.h //===-- SpecialCaseList.h - special case list for sanitizers ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception //===----------------------------------------------------------------------===// // // This file implements a Special Case List for code sanitizers. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SPECIALCASELIST_H #define LLVM_SUPPORT_SPECIALCASELIST_H llvm/include/llvm/Support/StringSaver.h //===- llvm/Support/StringSaver.h -------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_STRINGSAVER_H #define LLVM_SUPPORT_STRINGSAVER_H llvm/include/llvm/Support/SuffixTree.h //===- llvm/ADT/SuffixTree.h - Tree for substrings --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // A data structure for fast substring queries. // // Suffix trees represent the suffixes of their input strings in their leaves. // A suffix tree is a type of compressed trie structure where each node // represents an entire substring rather than a single character. Each leaf // of the tree is a suffix. // // A suffix tree can be seen as a type of state machine where each state is a // substring of the full string. The tree is structured so that, for a string // of length N, there are exactly N leaves in the tree. This structure allows // us to quickly find repeated substrings of the input string. // // In this implementation, a "string" is a vector of unsigned integers. // These integers may result from hashing some data type. A suffix tree can // contain 1 or many strings, which can then be queried as one large string. // // The suffix tree is implemented using Ukkonen's algorithm for linear-time // suffix tree construction. Ukkonen's algorithm is explained in more detail // in the paper by Esko Ukkonen "On-line construction of suffix trees. The // paper is available at // // https://www.cs.helsinki.fi/u/ukkonen/SuffixT1withFigs.pdf //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SUFFIXTREE_H #define LLVM_SUPPORT_SUFFIXTREE_H llvm/include/llvm/Support/SuffixTreeNode.h //===- llvm/ADT/SuffixTreeNode.h - Nodes for SuffixTrees --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines nodes for use within a SuffixTree. // // Each node has either no children or at least two children, with the root // being a exception in the empty tree. // // Children are represented as a map between unsigned integers and nodes. If // a node N has a child M on unsigned integer k, then the mapping represented // by N is a proper prefix of the mapping represented by M. Note that this, // although similar to a trie is somewhat different: each node stores a full // substring of the full mapping rather than a single character state. // // Each internal node contains a pointer to the internal node representing // the same string, but with the first character chopped off. This is stored // in \p Link. Each leaf node stores the start index of its respective // suffix in \p SuffixIdx. //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SUFFIXTREE_NODE_H #define LLVM_SUPPORT_SUFFIXTREE_NODE_H llvm/include/llvm/Support/SwapByteOrder.h //===- SwapByteOrder.h - Generic and optimized byte swaps -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares generic and optimized functions to swap the byte order of // an integral type. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_SWAPBYTEORDER_H #define LLVM_SUPPORT_SWAPBYTEORDER_H llvm/include/llvm/Support/SystemZ/zOSSupport.h //===- zOSSupport.h - Common z/OS Include File ------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines z/OS implementations for common functions. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_ZOSSUPPORT_H #define LLVM_SUPPORT_ZOSSUPPORT_H #ifdef __MVS__ llvm/include/llvm/Support/TarWriter.h //===-- llvm/Support/TarWriter.h - Tar archive file creator -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_TARWRITER_H #define LLVM_SUPPORT_TARWRITER_H llvm/include/llvm/Support/TargetSelect.h //===- TargetSelect.h - Target Selection & Registration ---------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file provides utilities to make sure that certain classes of targets are // linked into the main application executable, and initialize them as // appropriate. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_TARGETSELECT_H #define LLVM_SUPPORT_TARGETSELECT_H llvm/include/llvm/Support/ThreadPool.h //===-- llvm/Support/ThreadPool.h - A ThreadPool implementation -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines a crude C++11 based thread pool. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_THREADPOOL_H #define LLVM_SUPPORT_THREADPOOL_H llvm/include/llvm/Support/ThreadSafeAllocator.h //===- ThreadSafeAllocator.h ------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_THREADSAFEALLOCATOR_H #define LLVM_SUPPORT_THREADSAFEALLOCATOR_H llvm/include/llvm/Support/Threading.h //===-- llvm/Support/Threading.h - Control multithreading mode --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares helper functions for running LLVM in a multi-threaded // environment. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_THREADING_H #define LLVM_SUPPORT_THREADING_H llvm/include/llvm/Support/TimeProfiler.h //===- llvm/Support/TimeProfiler.h - Hierarchical Time Profiler -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This provides lightweight and dependency-free machinery to trace execution // time around arbitrary code. Two API flavors are available. // // The primary API uses a RAII object to trigger tracing: // // \code // { // TimeTraceScope scope("my_event_name"); // ...my code... // } // \endcode // // If the code to be profiled does not have a natural lexical scope then // it is also possible to start and end events with respect to an implicit // per-thread stack of profiling entries: // // \code // timeTraceProfilerBegin("my_event_name"); // ...my code... // timeTraceProfilerEnd(); // must be called on all control flow paths // \endcode // // Time profiling entries can be given an arbitrary name and, optionally, // an arbitrary 'detail' string. The resulting trace will include 'Total' // entries summing the time spent for each name. Thus, it's best to choose // names to be fairly generic, and rely on the detail field to capture // everything else of interest. // // To avoid lifetime issues name and detail strings are copied into the event // entries at their time of creation. Care should be taken to make string // construction cheap to prevent 'Heisenperf' effects. In particular, the // 'detail' argument may be a string-returning closure: // // \code // int n; // { // TimeTraceScope scope("my_event_name", // [n]() { return (Twine("x=") + Twine(n)).str(); }); // ...my code... // } // \endcode // The closure will not be called if tracing is disabled. Otherwise, the // resulting string will be directly moved into the entry. // // The main process should begin with a timeTraceProfilerInitialize, and // finish with timeTraceProfileWrite and timeTraceProfilerCleanup calls. // Each new thread should begin with a timeTraceProfilerInitialize, and // finish with a timeTraceProfilerFinishThread call. // // Timestamps come from std::chrono::stable_clock. Note that threads need // not see the same time from that clock, and the resolution may not be // the best available. // // Currently, there are a number of compatible viewers: // - chrome://tracing is the original chromium trace viewer. // - http://ui.perfetto.dev is the replacement for the above, under active // development by Google as part of the 'Perfetto' project. // - https://www.speedscope.app/ has also been reported as an option. // // Future work: // - Support akin to LLVM_DEBUG for runtime enable/disable of named tracing // families for non-debug builds which wish to support optional tracing. // - Evaluate the detail closures at profile write time to avoid // stringification costs interfering with tracing. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_TIMEPROFILER_H #define LLVM_SUPPORT_TIMEPROFILER_H llvm/include/llvm/Support/Timer.h //===-- llvm/Support/Timer.h - Interval Timing Support ----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_TIMER_H #define LLVM_SUPPORT_TIMER_H llvm/include/llvm/Support/ToolOutputFile.h //===- ToolOutputFile.h - Output files for compiler-like tools --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the ToolOutputFile class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_TOOLOUTPUTFILE_H #define LLVM_SUPPORT_TOOLOUTPUTFILE_H llvm/include/llvm/Support/TrailingObjects.h //===--- TrailingObjects.h - Variable-length classes ------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This header defines support for implementing classes that have /// some trailing object (or arrays of objects) appended to them. The /// main purpose is to make it obvious where this idiom is being used, /// and to make the usage more idiomatic and more difficult to get /// wrong. /// /// The TrailingObject template abstracts away the reinterpret_cast, /// pointer arithmetic, and size calculations used for the allocation /// and access of appended arrays of objects, and takes care that they /// are all allocated at their required alignment. Additionally, it /// ensures that the base type is final -- deriving from a class that /// expects data appended immediately after it is typically not safe. /// /// Users are expected to derive from this template, and provide /// numTrailingObjects implementations for each trailing type except /// the last, e.g. like this sample: /// /// \code /// class VarLengthObj : private TrailingObjects { /// friend TrailingObjects; /// /// unsigned NumInts, NumDoubles; /// size_t numTrailingObjects(OverloadToken) const { return NumInts; } /// }; /// \endcode /// /// You can access the appended arrays via 'getTrailingObjects', and /// determine the size needed for allocation via /// 'additionalSizeToAlloc' and 'totalSizeToAlloc'. /// /// All the methods implemented by this class are intended for use /// by the implementation of the class, not as part of its interface /// (thus, private inheritance is suggested). /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_TRAILINGOBJECTS_H #define LLVM_SUPPORT_TRAILINGOBJECTS_H llvm/include/llvm/Support/TypeName.h //===- TypeName.h -----------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_TYPENAME_H #define LLVM_SUPPORT_TYPENAME_H llvm/include/llvm/Support/TypeSize.h //===- TypeSize.h - Wrapper around type sizes -------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file provides a struct that can be used to query the size of IR types // which may be scalable vectors. It provides convenience operators so that // it can be used in much the same way as a single scalar value. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_TYPESIZE_H #define LLVM_SUPPORT_TYPESIZE_H llvm/include/llvm/Support/Unicode.h //===- llvm/Support/Unicode.h - Unicode character properties -*- C++ -*-=====// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines functions that allow querying certain properties of Unicode // characters. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_UNICODE_H #define LLVM_SUPPORT_UNICODE_H llvm/include/llvm/Support/UnicodeCharRanges.h //===--- UnicodeCharRanges.h - Types and functions for character ranges ---===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_UNICODECHARRANGES_H #define LLVM_SUPPORT_UNICODECHARRANGES_H llvm/include/llvm/Support/Valgrind.h //===- llvm/Support/Valgrind.h - Communication with Valgrind ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Methods for communicating with a valgrind instance this program is running // under. These are all no-ops unless LLVM was configured on a system with the // valgrind headers installed and valgrind is controlling this process. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_VALGRIND_H #define LLVM_SUPPORT_VALGRIND_H llvm/include/llvm/Support/VersionTuple.h //===- VersionTuple.h - Version Number Handling -----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// Defines the llvm::VersionTuple class, which represents a version in /// the form major[.minor[.subminor]]. /// //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_VERSIONTUPLE_H #define LLVM_SUPPORT_VERSIONTUPLE_H llvm/include/llvm/Support/VirtualFileSystem.h //===- VirtualFileSystem.h - Virtual File System Layer ----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // /// \file /// Defines the virtual file system interface vfs::FileSystem. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_VIRTUALFILESYSTEM_H #define LLVM_SUPPORT_VIRTUALFILESYSTEM_H llvm/include/llvm/Support/Watchdog.h //===--- Watchdog.h - Watchdog timer ----------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file declares the llvm::sys::Watchdog class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_WATCHDOG_H #define LLVM_SUPPORT_WATCHDOG_H llvm/include/llvm/Support/Win64EH.h //===-- llvm/Support/Win64EH.h ---Win64 EH Constants-------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains constants and structures used for implementing // exception handling on Win64 platforms. For more information, see // http://msdn.microsoft.com/en-us/library/1eyas8tf.aspx // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_WIN64EH_H #define LLVM_SUPPORT_WIN64EH_H llvm/include/llvm/Support/Windows/WindowsSupport.h //===- WindowsSupport.h - Common Windows Include File -----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines things specific to Windows implementations. In addition to // providing some helpers for working with win32 APIs, this header wraps // with some portability macros. Always include WindowsSupport.h // instead of including directly. // //===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===// //=== WARNING: Implementation here must contain only generic Win32 code that //=== is guaranteed to work on *all* Win32 variants. //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_WINDOWSSUPPORT_H #define LLVM_SUPPORT_WINDOWSSUPPORT_H // mingw-w64 tends to define it as 0x0502 in its headers. #undef _WIN32_WINNT // Require at least Windows 7 API. #define _WIN32_WINNT 0x0601 #define WIN32_LEAN_AND_MEAN #ifndef NOMINMAX #define NOMINMAX #endif llvm/include/llvm/Support/WindowsError.h //===-- WindowsError.h - Support for mapping windows errors to posix-------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_WINDOWSERROR_H #define LLVM_SUPPORT_WINDOWSERROR_H llvm/include/llvm/Support/WithColor.h //===- WithColor.h ----------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_WITHCOLOR_H #define LLVM_SUPPORT_WITHCOLOR_H llvm/include/llvm/Support/X86DisassemblerDecoderCommon.h //===-- X86DisassemblerDecoderCommon.h - Disassembler decoder ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is part of the X86 Disassembler. // It contains common definitions used by both the disassembler and the table // generator. // Documentation for the disassembler can be found in X86Disassembler.h. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_X86DISASSEMBLERDECODERCOMMON_H #define LLVM_SUPPORT_X86DISASSEMBLERDECODERCOMMON_H llvm/include/llvm/Support/YAMLParser.h //===- YAMLParser.h - Simple YAML parser ------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This is a YAML 1.2 parser. // // See http://www.yaml.org/spec/1.2/spec.html for the full standard. // // This currently does not implement the following: // * Tag resolution. // * UTF-16. // * BOMs anywhere other than the first Unicode scalar value in the file. // // The most important class here is Stream. This represents a YAML stream with // 0, 1, or many documents. // // SourceMgr sm; // StringRef input = getInput(); // yaml::Stream stream(input, sm); // // for (yaml::document_iterator di = stream.begin(), de = stream.end(); // di != de; ++di) { // yaml::Node *n = di->getRoot(); // if (n) { // // Do something with n... // } else // break; // } // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_YAMLPARSER_H #define LLVM_SUPPORT_YAMLPARSER_H llvm/include/llvm/Support/YAMLTraits.h //===- llvm/Support/YAMLTraits.h --------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_YAMLTRAITS_H #define LLVM_SUPPORT_YAMLTRAITS_H llvm/include/llvm/Support/circular_raw_ostream.h //===-- llvm/Support/circular_raw_ostream.h - Buffered streams --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains raw_ostream implementations for streams to do circular // buffering of their output. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_CIRCULAR_RAW_OSTREAM_H #define LLVM_SUPPORT_CIRCULAR_RAW_OSTREAM_H llvm/include/llvm/Support/raw_os_ostream.h //===- raw_os_ostream.h - std::ostream adaptor for raw_ostream --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the raw_os_ostream class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_RAW_OS_OSTREAM_H #define LLVM_SUPPORT_RAW_OS_OSTREAM_H llvm/include/llvm/Support/raw_ostream.h //===--- raw_ostream.h - Raw output stream ----------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the raw_ostream class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_RAW_OSTREAM_H #define LLVM_SUPPORT_RAW_OSTREAM_H llvm/include/llvm/Support/raw_sha1_ostream.h //==- raw_sha1_ostream.h - raw_ostream that compute SHA1 --*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the raw_sha1_ostream class. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_RAW_SHA1_OSTREAM_H #define LLVM_SUPPORT_RAW_SHA1_OSTREAM_H llvm/include/llvm/Support/raw_socket_stream.h //===-- llvm/Support/raw_socket_stream.h - Socket streams --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains raw_ostream implementations for streams to communicate // via UNIX sockets // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_RAW_SOCKET_STREAM_H #define LLVM_SUPPORT_RAW_SOCKET_STREAM_H llvm/include/llvm/Support/thread.h //===-- llvm/Support/thread.h - Wrapper for ------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This header is a wrapper for that works around problems with the // MSVC headers when exceptions are disabled. It also provides llvm::thread, // which is either a typedef of std::thread or a replacement that calls the // function synchronously depending on the value of LLVM_ENABLE_THREADS. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_THREAD_H #define LLVM_SUPPORT_THREAD_H llvm/include/llvm/Support/type_traits.h //===- llvm/Support/type_traits.h - Simplfied type traits -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file provides useful additions to the standard type_traits library. // //===----------------------------------------------------------------------===// #ifndef LLVM_SUPPORT_TYPE_TRAITS_H #define LLVM_SUPPORT_TYPE_TRAITS_H llvm/include/llvm/Support/xxhash.h /* xxHash - Extremely Fast Hash algorithm Header File Copyright (C) 2012-2016, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - xxHash source repository : https://github.com/Cyan4973/xxHash */ /* based on revision d2df04efcbef7d7f6886d345861e5dfda4edacc1 Removed * everything but a simple interface for computing XXh64. */ #ifndef LLVM_SUPPORT_XXHASH_H #define LLVM_SUPPORT_XXHASH_H llvm/include/llvm/ADT/ADL.h //===- llvm/ADT/ADL.h - Argument dependent lookup utilities -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ADL_H #define LLVM_ADT_ADL_H llvm/include/llvm/ADT/APFixedPoint.h //===- APFixedPoint.h - Fixed point constant handling -----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// Defines the fixed point number interface. /// This is a class for abstracting various operations performed on fixed point /// types. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_APFIXEDPOINT_H #define LLVM_ADT_APFIXEDPOINT_H llvm/include/llvm/ADT/APFloat.h //===- llvm/ADT/APFloat.h - Arbitrary Precision Floating Point ---*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/APInt.h //===-- llvm/ADT/APInt.h - For Arbitrary Precision Integer -----*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file implements a class to represent arbitrary precision /// integral constant values and operations on them. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_APINT_H #define LLVM_ADT_APINT_H llvm/include/llvm/ADT/APSInt.h //===-- llvm/ADT/APSInt.h - Arbitrary Precision Signed Int -----*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/AddressRanges.h //===- AddressRanges.h ------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ADDRESSRANGES_H #define LLVM_ADT_ADDRESSRANGES_H llvm/include/llvm/ADT/AllocatorList.h //===- llvm/ADT/AllocatorList.h - Custom allocator list ---------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ALLOCATORLIST_H #define LLVM_ADT_ALLOCATORLIST_H llvm/include/llvm/ADT/Any.h //===- Any.h - Generic type erased holder of any type -----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file provides Any, a non-template class modeled in the spirit of /// std::any. The idea is to provide a type-safe replacement for C's void*. /// It can hold a value of any copy-constructible copy-assignable type /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ANY_H #define LLVM_ADT_ANY_H llvm/include/llvm/ADT/ArrayRef.h //===- ArrayRef.h - Array Reference Wrapper ---------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ARRAYREF_H #define LLVM_ADT_ARRAYREF_H llvm/include/llvm/ADT/BitVector.h //===- llvm/ADT/BitVector.h - Bit vectors -----------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file implements the BitVector class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_BITVECTOR_H #define LLVM_ADT_BITVECTOR_H llvm/include/llvm/ADT/Bitfields.h //===-- llvm/ADT/Bitfield.h - Get and Set bits in an integer ---*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file implements methods to test, set and extract typed bits from packed /// unsigned integers. /// /// Why not C++ bitfields? /// ---------------------- /// C++ bitfields do not offer control over the bit layout nor consistent /// behavior when it comes to out of range values. /// For instance, the layout is implementation defined and adjacent bits may be /// packed together but are not required to. This is problematic when storage is /// sparse and data must be stored in a particular integer type. /// /// The methods provided in this file ensure precise control over the /// layout/storage as well as protection against out of range values. /// /// Usage example /// ------------- /// \code{.cpp} /// uint8_t Storage = 0; /// /// // Store and retrieve a single bit as bool. /// using Bool = Bitfield::Element; /// Bitfield::set(Storage, true); /// EXPECT_EQ(Storage, 0b00000001); /// // ^ /// EXPECT_EQ(Bitfield::get(Storage), true); /// /// // Store and retrieve a 2 bit typed enum. /// // Note: enum underlying type must be unsigned. /// enum class SuitEnum : uint8_t { CLUBS, DIAMONDS, HEARTS, SPADES }; /// // Note: enum maximum value needs to be passed in as last parameter. /// using Suit = Bitfield::Element; /// Bitfield::set(Storage, SuitEnum::HEARTS); /// EXPECT_EQ(Storage, 0b00000101); /// // ^^ /// EXPECT_EQ(Bitfield::get(Storage), SuitEnum::HEARTS); /// /// // Store and retrieve a 5 bit value as unsigned. /// using Value = Bitfield::Element; /// Bitfield::set(Storage, 10); /// EXPECT_EQ(Storage, 0b01010101); /// // ^^^^^ /// EXPECT_EQ(Bitfield::get(Storage), 10U); /// /// // Interpret the same 5 bit value as signed. /// using SignedValue = Bitfield::Element; /// Bitfield::set(Storage, -2); /// EXPECT_EQ(Storage, 0b11110101); /// // ^^^^^ /// EXPECT_EQ(Bitfield::get(Storage), -2); /// /// // Ability to efficiently test if a field is non zero. /// EXPECT_TRUE(Bitfield::test(Storage)); /// /// // Alter Storage changes value. /// Storage = 0; /// EXPECT_EQ(Bitfield::get(Storage), false); /// EXPECT_EQ(Bitfield::get(Storage), SuitEnum::CLUBS); /// EXPECT_EQ(Bitfield::get(Storage), 0U); /// EXPECT_EQ(Bitfield::get(Storage), 0); /// /// Storage = 255; /// EXPECT_EQ(Bitfield::get(Storage), true); /// EXPECT_EQ(Bitfield::get(Storage), SuitEnum::SPADES); /// EXPECT_EQ(Bitfield::get(Storage), 31U); /// EXPECT_EQ(Bitfield::get(Storage), -1); /// \endcode /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_BITFIELDS_H #define LLVM_ADT_BITFIELDS_H llvm/include/llvm/ADT/BitmaskEnum.h //===-- llvm/ADT/BitmaskEnum.h ----------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_BITMASKENUM_H #define LLVM_ADT_BITMASKENUM_H llvm/include/llvm/ADT/Bitset.h //=== llvm/ADT/Bitset.h - constexpr std::bitset -----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Defines a std::bitset like container that can be used in constexprs. // That constructor and many of the methods are constexpr. std::bitset doesn't // get constexpr methods until C++23. This class also provides a constexpr // constructor that accepts an initializer_list of bits to set. // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_BITSET_H #define LLVM_ADT_BITSET_H llvm/include/llvm/ADT/BreadthFirstIterator.h //===- llvm/ADT/BreadthFirstIterator.h - Breadth First iterator -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file builds on the ADT/GraphTraits.h file to build a generic breadth /// first graph iterator. This file exposes the following functions/types: /// /// bf_begin/bf_end/bf_iterator /// * Normal breadth-first iteration - visit a graph level-by-level. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_BREADTHFIRSTITERATOR_H #define LLVM_ADT_BREADTHFIRSTITERATOR_H llvm/include/llvm/ADT/CachedHashString.h //===- llvm/ADT/CachedHashString.h - Prehashed string/StringRef -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines CachedHashString and CachedHashStringRef. These are /// owning and not-owning string types that store their hash in addition to /// their string data. /// /// Unlike std::string, CachedHashString can be used in DenseSet/DenseMap /// (because, unlike std::string, CachedHashString lets us have empty and /// tombstone values). /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_CACHEDHASHSTRING_H #define LLVM_ADT_CACHEDHASHSTRING_H llvm/include/llvm/ADT/CoalescingBitVector.h //===- llvm/ADT/CoalescingBitVector.h - A coalescing bitvector --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// A bitvector that uses an IntervalMap to coalesce adjacent elements /// into intervals. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_COALESCINGBITVECTOR_H #define LLVM_ADT_COALESCINGBITVECTOR_H llvm/include/llvm/ADT/CombinationGenerator.h //===-- llvm/ADT/CombinationGenerator.h ------------------------*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// Combination generator. /// /// Example: given input {{0, 1}, {2}, {3, 4}} it will produce the following /// combinations: {0, 2, 3}, {0, 2, 4}, {1, 2, 3}, {1, 2, 4}. /// /// It is useful to think of input as vector-of-vectors, where the /// outer vector is the variable space, and inner vector is choice space. /// The number of choices for each variable can be different. /// /// As for implementation, it is useful to think of this as a weird number, /// where each digit (==variable) may have different base (==number of choices). /// Thus modelling of 'produce next combination' is exactly analogous to the /// incrementing of an number - increment lowest digit (pick next choice for the /// variable), and if it wrapped to the beginning then increment next digit. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_COMBINATIONGENERATOR_H #define LLVM_ADT_COMBINATIONGENERATOR_H llvm/include/llvm/ADT/ConcurrentHashtable.h //===- ConcurrentHashtable.h ------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_CONCURRENTHASHTABLE_H #define LLVM_ADT_CONCURRENTHASHTABLE_H llvm/include/llvm/ADT/DAGDeltaAlgorithm.h //===- DAGDeltaAlgorithm.h - A DAG Minimization Algorithm ------*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_DAGDELTAALGORITHM_H #define LLVM_ADT_DAGDELTAALGORITHM_H llvm/include/llvm/ADT/DeltaAlgorithm.h //===- DeltaAlgorithm.h - A Set Minimization Algorithm ---------*- C++ -*--===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_DELTAALGORITHM_H #define LLVM_ADT_DELTAALGORITHM_H llvm/include/llvm/ADT/DenseMap.h //===- llvm/ADT/DenseMap.h - Dense probed hash table ------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the DenseMap class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_DENSEMAP_H #define LLVM_ADT_DENSEMAP_H llvm/include/llvm/ADT/DenseMapInfo.h //===- llvm/ADT/DenseMapInfo.h - Type traits for DenseMap -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines DenseMapInfo traits for DenseMap. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_DENSEMAPINFO_H #define LLVM_ADT_DENSEMAPINFO_H llvm/include/llvm/ADT/DenseMapInfoVariant.h //===- DenseMapInfoVariant.h - Type traits for DenseMap *- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines DenseMapInfo traits for DenseMap>. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_DENSEMAPINFOVARIANT_H #define LLVM_ADT_DENSEMAPINFOVARIANT_H llvm/include/llvm/ADT/DenseSet.h //===- llvm/ADT/DenseSet.h - Dense probed hash table ------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the DenseSet and SmallDenseSet classes. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_DENSESET_H #define LLVM_ADT_DENSESET_H llvm/include/llvm/ADT/DepthFirstIterator.h //===- llvm/ADT/DepthFirstIterator.h - Depth First iterator -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/DirectedGraph.h //===- llvm/ADT/DirectedGraph.h - Directed Graph ----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the interface and a base class implementation for a /// directed graph. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_DIRECTEDGRAPH_H #define LLVM_ADT_DIRECTEDGRAPH_H llvm/include/llvm/ADT/DynamicAPInt.h //===- DynamicAPInt.h - DynamicAPInt Class ----------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This is a simple class to represent arbitrary precision signed integers. // Unlike APInt, one does not have to specify a fixed maximum size, and the // integer can take on any arbitrary values. This is optimized for small-values // by providing fast-paths for the cases when the value stored fits in 64-bits. // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_DYNAMICAPINT_H #define LLVM_ADT_DYNAMICAPINT_H llvm/include/llvm/ADT/EnumeratedArray.h //===- llvm/ADT/EnumeratedArray.h - Enumerated Array-------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines an array type that can be indexed using scoped enum /// values. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ENUMERATEDARRAY_H #define LLVM_ADT_ENUMERATEDARRAY_H llvm/include/llvm/ADT/EpochTracker.h //===- llvm/ADT/EpochTracker.h - ADT epoch tracking --------------*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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_EPOCHTRACKER_H #define LLVM_ADT_EPOCHTRACKER_H llvm/include/llvm/ADT/EquivalenceClasses.h //===- llvm/ADT/EquivalenceClasses.h - Generic Equiv. Classes ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// Generic implementation of equivalence classes through the use Tarjan's /// efficient union-find algorithm. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_EQUIVALENCECLASSES_H #define LLVM_ADT_EQUIVALENCECLASSES_H llvm/include/llvm/ADT/FloatingPointMode.h //===- llvm/Support/FloatingPointMode.h -------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// Utilities for dealing with flags related to floating point properties and /// mode controls. /// //===----------------------------------------------------------------------===/ #ifndef LLVM_ADT_FLOATINGPOINTMODE_H #define LLVM_ADT_FLOATINGPOINTMODE_H llvm/include/llvm/ADT/FoldingSet.h //===- llvm/ADT/FoldingSet.h - Uniquing Hash Set ----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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. //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_FOLDINGSET_H #define LLVM_ADT_FOLDINGSET_H llvm/include/llvm/ADT/FunctionExtras.h //===- FunctionExtras.h - Function type erasure utilities -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// This file provides a collection of function (or more generally, callable) /// type erasure utilities supplementing those provided by the standard library /// in ``. /// /// It provides `unique_function`, which works like `std::function` but supports /// move-only callable objects and const-qualification. /// /// Future plans: /// - Add a `function` that provides ref-qualified support, which doesn't work /// with `std::function`. /// - Provide support for specifying multiple signatures to type erase callable /// objects with an overload set, such as those produced by generic lambdas. /// - Expand to include a copyable utility that directly replaces std::function /// but brings the above improvements. /// /// Note that LLVM's utilities are greatly simplified by not supporting /// allocators. /// /// If the standard library ever begins to provide comparable facilities we can /// consider switching to those. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_FUNCTIONEXTRAS_H #define LLVM_ADT_FUNCTIONEXTRAS_H llvm/include/llvm/ADT/GenericConvergenceVerifier.h //===- GenericConvergenceVerifier.h ---------------------------*- C++ -*---===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// /// A verifier for the static rules of convergence control tokens that works /// with both LLVM IR and MIR. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_GENERICCONVERGENCEVERIFIER_H #define LLVM_ADT_GENERICCONVERGENCEVERIFIER_H llvm/include/llvm/ADT/GenericCycleImpl.h //===- GenericCycleImpl.h -------------------------------------*- C++ -*---===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This template implementation resides in a separate file so that it /// does not get injected into every .cpp file that includes the /// generic header. /// /// DO NOT INCLUDE THIS FILE WHEN MERELY USING CYCLEINFO. /// /// This file should only be included by files that implement a /// specialization of the relevant templates. Currently these are: /// - llvm/lib/IR/CycleInfo.cpp /// - llvm/lib/CodeGen/MachineCycleAnalysis.cpp /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_GENERICCYCLEIMPL_H #define LLVM_ADT_GENERICCYCLEIMPL_H llvm/include/llvm/ADT/GenericCycleInfo.h //===- GenericCycleInfo.h - Info for Cycles in any IR ------*- C++ -*------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// \brief Find all cycles in a control-flow graph, including irreducible loops. /// /// See docs/CycleTerminology.rst for a formal definition of cycles. /// /// Briefly: /// - A cycle is a generalization of a loop which can represent /// irreducible control flow. /// - Cycles identified in a program are implementation defined, /// depending on the DFS traversal chosen. /// - Cycles are well-nested, and form a forest with a parent-child /// relationship. /// - In any choice of DFS, every natural loop L is represented by a /// unique cycle C which is a superset of L. /// - In the absence of irreducible control flow, the cycles are /// exactly the natural loops in the program. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_GENERICCYCLEINFO_H #define LLVM_ADT_GENERICCYCLEINFO_H llvm/include/llvm/ADT/GenericSSAContext.h //===- GenericSSAContext.h --------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// /// This file defines the little GenericSSAContext template class /// that can be used to implement IR analyses as templates. /// Specializing these templates allows the analyses to be used over /// both LLVM IR and Machine IR. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_GENERICSSACONTEXT_H #define LLVM_ADT_GENERICSSACONTEXT_H llvm/include/llvm/ADT/GenericUniformityImpl.h //===- GenericUniformityImpl.h -----------------------*- C++ -*------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This template implementation resides in a separate file so that it // does not get injected into every .cpp file that includes the // generic header. // // DO NOT INCLUDE THIS FILE WHEN MERELY USING UNIFORMITYINFO. // // This file should only be included by files that implement a // specialization of the relvant templates. Currently these are: // - UniformityAnalysis.cpp // // Note: The DEBUG_TYPE macro should be defined before using this // file so that any use of LLVM_DEBUG is associated with the // including file rather than this file. // //===----------------------------------------------------------------------===// /// /// \file /// \brief Implementation of uniformity analysis. /// /// The algorithm is a fixed point iteration that starts with the assumption /// that all control flow and all values are uniform. Starting from sources of /// divergence (whose discovery must be implemented by a CFG- or even /// target-specific derived class), divergence of values is propagated from /// definition to uses in a straight-forward way. The main complexity lies in /// the propagation of the impact of divergent control flow on the divergence of /// values (sync dependencies). /// /// NOTE: In general, no interface exists for a transform to update /// (Machine)UniformityInfo. Additionally, (Machine)CycleAnalysis is a /// transitive dependence, but it also does not provide an interface for /// updating itself. Given that, transforms should not preserve uniformity in /// their getAnalysisUsage() callback. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_GENERICUNIFORMITYIMPL_H #define LLVM_ADT_GENERICUNIFORMITYIMPL_H llvm/include/llvm/ADT/GenericUniformityInfo.h //===- GenericUniformityInfo.h ---------------------------*- C++ -*--------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_GENERICUNIFORMITYINFO_H #define LLVM_ADT_GENERICUNIFORMITYINFO_H llvm/include/llvm/ADT/GraphTraits.h //===- llvm/ADT/GraphTraits.h - Graph traits template -----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the little GraphTraits 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 llvm/include/llvm/ADT/Hashing.h //===-- llvm/ADT/Hashing.h - Utilities for hashing --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // 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: // // -- '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 llvm/include/llvm/ADT/ImmutableList.h //==--- ImmutableList.h - Immutable (functional) list interface --*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the ImmutableList class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_IMMUTABLELIST_H #define LLVM_ADT_IMMUTABLELIST_H llvm/include/llvm/ADT/ImmutableMap.h //===--- ImmutableMap.h - Immutable (functional) map interface --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the ImmutableMap class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_IMMUTABLEMAP_H #define LLVM_ADT_IMMUTABLEMAP_H llvm/include/llvm/ADT/ImmutableSet.h //===--- ImmutableSet.h - Immutable (functional) set interface --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the ImutAVLTree and ImmutableSet classes. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_IMMUTABLESET_H #define LLVM_ADT_IMMUTABLESET_H llvm/include/llvm/ADT/IndexedMap.h //===- llvm/ADT/IndexedMap.h - An index map implementation ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/IntEqClasses.h //===-- llvm/ADT/IntEqClasses.h - Equiv. Classes of Integers ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/IntervalMap.h //===- llvm/ADT/IntervalMap.h - A sorted interval map -----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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. /// /// 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. // //===----------------------------------------------------------------------===// // // Synopsis: // // template // 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 // class IntervalMap::const_iterator { // public: // using iterator_category = std::bidirectional_iterator_tag; // using value_type = ValT; // using difference_type = std::ptrdiff_t; // using pointer = value_type *; // using reference = value_type &; // // 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 // class IntervalMap::iterator : public const_iterator { // public: // void insert(KeyT a, KeyT b, Value y); // void erase(); // }; // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_INTERVALMAP_H #define LLVM_ADT_INTERVALMAP_H llvm/include/llvm/ADT/IntervalTree.h //===-- IntervalTree.h ------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements an interval tree. // // Further information: // https://en.wikipedia.org/wiki/Interval_tree // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_INTERVALTREE_H #define LLVM_ADT_INTERVALTREE_H llvm/include/llvm/ADT/IntrusiveRefCntPtr.h //==- llvm/ADT/IntrusiveRefCntPtr.h - Smart Refcounting Pointer --*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the RefCountedBase, ThreadSafeRefCountedBase, and /// IntrusiveRefCntPtr classes. /// /// IntrusiveRefCntPtr is a smart pointer to an object which maintains a /// reference count. (ThreadSafe)RefCountedBase is a mixin class that adds a /// refcount member variable and methods for updating the refcount. An object /// that inherits from (ThreadSafe)RefCountedBase deletes itself when its /// refcount hits zero. /// /// For example: /// /// ``` /// class MyClass : public RefCountedBase {}; /// /// void foo() { /// // Constructing an IntrusiveRefCntPtr increases the pointee's refcount /// // by 1 (from 0 in this case). /// IntrusiveRefCntPtr Ptr1(new MyClass()); /// /// // Copying an IntrusiveRefCntPtr increases the pointee's refcount by 1. /// IntrusiveRefCntPtr Ptr2(Ptr1); /// /// // Constructing an IntrusiveRefCntPtr has no effect on the object's /// // refcount. After a move, the moved-from pointer is null. /// IntrusiveRefCntPtr Ptr3(std::move(Ptr1)); /// assert(Ptr1 == nullptr); /// /// // Clearing an IntrusiveRefCntPtr decreases the pointee's refcount by 1. /// Ptr2.reset(); /// /// // The object deletes itself when we return from the function, because /// // Ptr3's destructor decrements its refcount to 0. /// } /// ``` /// /// You can use IntrusiveRefCntPtr with isa(), dyn_cast(), etc.: /// /// ``` /// IntrusiveRefCntPtr Ptr(new MyClass()); /// OtherClass *Other = dyn_cast(Ptr); // Ptr.get() not required /// ``` /// /// IntrusiveRefCntPtr works with any class that /// /// - inherits from (ThreadSafe)RefCountedBase, /// - has Retain() and Release() methods, or /// - specializes IntrusiveRefCntPtrInfo. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_INTRUSIVEREFCNTPTR_H #define LLVM_ADT_INTRUSIVEREFCNTPTR_H llvm/include/llvm/ADT/LazyAtomicPointer.h //===- LazyAtomicPointer.----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_LAZYATOMICPOINTER_H #define LLVM_ADT_LAZYATOMICPOINTER_H llvm/include/llvm/ADT/MapVector.h //===- llvm/ADT/MapVector.h - Map w/ deterministic value order --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 SmallVector. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_MAPVECTOR_H #define LLVM_ADT_MAPVECTOR_H llvm/include/llvm/ADT/PackedVector.h //===- llvm/ADT/PackedVector.h - Packed values vector -----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file implements the PackedVector class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_PACKEDVECTOR_H #define LLVM_ADT_PACKEDVECTOR_H llvm/include/llvm/ADT/PagedVector.h //===- llvm/ADT/PagedVector.h - 'Lazily allocated' vectors --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the PagedVector class. // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_PAGEDVECTOR_H #define LLVM_ADT_PAGEDVECTOR_H llvm/include/llvm/ADT/PointerEmbeddedInt.h //===- llvm/ADT/PointerEmbeddedInt.h ----------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_POINTEREMBEDDEDINT_H #define LLVM_ADT_POINTEREMBEDDEDINT_H llvm/include/llvm/ADT/PointerIntPair.h //===- llvm/ADT/PointerIntPair.h - Pair for pointer and int -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the PointerIntPair class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_POINTERINTPAIR_H #define LLVM_ADT_POINTERINTPAIR_H llvm/include/llvm/ADT/PointerSumType.h //===- llvm/ADT/PointerSumType.h --------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_POINTERSUMTYPE_H #define LLVM_ADT_POINTERSUMTYPE_H llvm/include/llvm/ADT/PointerUnion.h //===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the PointerUnion class, which is a discriminated union of /// pointer types. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_POINTERUNION_H #define LLVM_ADT_POINTERUNION_H llvm/include/llvm/ADT/PostOrderIterator.h //===- llvm/ADT/PostOrderIterator.h - PostOrder iterator --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/PriorityQueue.h //===- llvm/ADT/PriorityQueue.h - Priority queues ---------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the PriorityQueue class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_PRIORITYQUEUE_H #define LLVM_ADT_PRIORITYQUEUE_H llvm/include/llvm/ADT/PriorityWorklist.h //===- PriorityWorklist.h - Worklist with insertion priority ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// /// This file provides a priority worklist. See the class comments for details. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_PRIORITYWORKLIST_H #define LLVM_ADT_PRIORITYWORKLIST_H llvm/include/llvm/ADT/RewriteBuffer.h //===- RewriteBuffer.h - Buffer rewriting interface -------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_REWRITEBUFFER_H #define LLVM_ADT_REWRITEBUFFER_H llvm/include/llvm/ADT/RewriteRope.h //===- RewriteRope.h - Rope specialized for rewriter ------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the RewriteRope class, which is a powerful string class. // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_REWRITEROPE_H #define LLVM_ADT_REWRITEROPE_H llvm/include/llvm/ADT/SCCIterator.h //===- ADT/SCCIterator.h - Strongly Connected Comp. Iter. -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \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. /// /// 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.) /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_SCCITERATOR_H #define LLVM_ADT_SCCITERATOR_H llvm/include/llvm/ADT/STLExtras.h //===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_STLEXTRAS_H #define LLVM_ADT_STLEXTRAS_H llvm/include/llvm/ADT/STLForwardCompat.h //===- STLForwardCompat.h - Library features from future STLs ------C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file contains library features backported from future STL versions. /// /// These should be replaced with their STL counterparts as the C++ version LLVM /// is compiled with is updated. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_STLFORWARDCOMPAT_H #define LLVM_ADT_STLFORWARDCOMPAT_H llvm/include/llvm/ADT/STLFunctionalExtras.h //===- llvm/ADT/STLFunctionalExtras.h - Extras for -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains some extension to . // // No library is required when using these functions. // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_STLFUNCTIONALEXTRAS_H #define LLVM_ADT_STLFUNCTIONALEXTRAS_H llvm/include/llvm/ADT/ScopeExit.h //===- llvm/ADT/ScopeExit.h - Execute code at scope exit --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the make_scope_exit function, which executes user-defined /// cleanup logic at scope exit. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_SCOPEEXIT_H #define LLVM_ADT_SCOPEEXIT_H llvm/include/llvm/ADT/ScopedHashTable.h //===- ScopedHashTable.h - A simple scoped hash table -----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // 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 HT; // { // ScopedHashTableScope Scope1(HT); // HT.insert(0, 0); // HT.insert(1, 1); // { // ScopedHashTableScope 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 llvm/include/llvm/ADT/Sequence.h //===- Sequence.h - Utility for producing sequences of values ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \file /// Provides some synthesis utilities to produce sequences of values. The names /// are intentionally kept very short as they tend to occur in common and /// widely used contexts. /// /// The `seq(A, B)` function produces a sequence of values from `A` to up to /// (but not including) `B`, i.e., [`A`, `B`), that can be safely iterated over. /// `seq` supports both integral (e.g., `int`, `char`, `uint32_t`) and enum /// types. `seq_inclusive(A, B)` produces a sequence of values from `A` to `B`, /// including `B`. /// /// Examples with integral types: /// ``` /// for (int x : seq(0, 3)) /// outs() << x << " "; /// ``` /// /// Prints: `0 1 2 `. /// /// ``` /// for (int x : seq_inclusive(0, 3)) /// outs() << x << " "; /// ``` /// /// Prints: `0 1 2 3 `. /// /// Similar to `seq` and `seq_inclusive`, the `enum_seq` and /// `enum_seq_inclusive` functions produce sequences of enum values that can be /// iterated over. /// To enable iteration with enum types, you need to either mark enums as safe /// to iterate on by specializing `enum_iteration_traits`, or opt into /// potentially unsafe iteration at every callsite by passing /// `force_iteration_on_noniterable_enum`. /// /// Examples with enum types: /// ``` /// namespace X { /// enum class MyEnum : unsigned {A = 0, B, C}; /// } // namespace X /// /// template <> struct enum_iteration_traits { /// static contexpr bool is_iterable = true; /// }; /// /// class MyClass { /// public: /// enum Safe { D = 3, E, F }; /// enum MaybeUnsafe { G = 1, H = 2, I = 4 }; /// }; /// /// template <> struct enum_iteration_traits { /// static contexpr bool is_iterable = true; /// }; /// ``` /// /// ``` /// for (auto v : enum_seq(MyClass::Safe::D, MyClass::Safe::F)) /// outs() << int(v) << " "; /// ``` /// /// Prints: `3 4 `. /// /// ``` /// for (auto v : enum_seq(MyClass::MaybeUnsafe::H, MyClass::MaybeUnsafe::I, /// force_iteration_on_noniterable_enum)) /// outs() << int(v) << " "; /// ``` /// /// Prints: `2 3 `. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_SEQUENCE_H #define LLVM_ADT_SEQUENCE_H llvm/include/llvm/ADT/SetOperations.h //===-- llvm/ADT/SetOperations.h - Generic Set Operations -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/SetVector.h //===- llvm/ADT/SetVector.h - Set with insert order iteration ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/SlowDynamicAPInt.h //===- SlowDynamicAPInt.h - SlowDynamicAPInt Class --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This is a simple class to represent arbitrary precision signed integers. // Unlike APInt, one does not have to specify a fixed maximum size, and the // integer can take on any arbitrary values. // // This class is to be used as a fallback slow path for the DynamicAPInt class, // and is not intended to be used directly. // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_SLOWDYNAMICAPINT_H #define LLVM_ADT_SLOWDYNAMICAPINT_H llvm/include/llvm/ADT/SmallBitVector.h //===- llvm/ADT/SmallBitVector.h - 'Normally small' bit vectors -*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file implements the SmallBitVector class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_SMALLBITVECTOR_H #define LLVM_ADT_SMALLBITVECTOR_H llvm/include/llvm/ADT/SmallPtrSet.h //===- llvm/ADT/SmallPtrSet.h - 'Normally small' pointer set ----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/SmallSet.h //===- llvm/ADT/SmallSet.h - 'Normally small' sets --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the SmallSet class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_SMALLSET_H #define LLVM_ADT_SMALLSET_H llvm/include/llvm/ADT/SmallString.h //===- llvm/ADT/SmallString.h - 'Normally small' strings --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the SmallString class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_SMALLSTRING_H #define LLVM_ADT_SMALLSTRING_H llvm/include/llvm/ADT/SmallVector.h //===- llvm/ADT/SmallVector.h - 'Normally small' vectors --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the SmallVector class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_SMALLVECTOR_H #define LLVM_ADT_SMALLVECTOR_H llvm/include/llvm/ADT/SmallVectorExtras.h //===- llvm/ADT/SmallVectorExtras.h -----------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines less commonly used SmallVector utilities. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_SMALLVECTOREXTRAS_H #define LLVM_ADT_SMALLVECTOREXTRAS_H llvm/include/llvm/ADT/SparseBitVector.h //===- llvm/ADT/SparseBitVector.h - Efficient Sparse BitVector --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/SparseMultiSet.h //===- llvm/ADT/SparseMultiSet.h - Sparse multiset --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/SparseSet.h //===- llvm/ADT/SparseSet.h - Sparse set ------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/StableHashing.h //===- llvm/ADT/StableHashing.h - Utilities for stable hashing * C++ *-----===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file provides types and functions for computing and combining stable // hashes. Stable hashes can be useful for hashing across different modules, // processes, machines, or compiler runs for a specific compiler version. It // currently employs the xxh3_64bits hashing algorithm. Be aware that this // implementation may be adjusted or updated as improvements to the compiler are // made. // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_STABLEHASHING_H #define LLVM_ADT_STABLEHASHING_H llvm/include/llvm/ADT/Statistic.h //===-- llvm/ADT/Statistic.h - Easy way to expose stats ---------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/StringExtras.h //===- llvm/ADT/StringExtras.h - Useful string functions --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file contains some functions that are useful when dealing with strings. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_STRINGEXTRAS_H #define LLVM_ADT_STRINGEXTRAS_H llvm/include/llvm/ADT/StringMap.h //===- StringMap.h - String Hash table map interface ------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the StringMap class. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_STRINGMAP_H #define LLVM_ADT_STRINGMAP_H llvm/include/llvm/ADT/StringMapEntry.h //===- StringMapEntry.h - String Hash table map interface -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file defines the StringMapEntry class - it is intended to be a low /// dependency implementation detail of StringMap that is more suitable for /// inclusion in public headers than StringMap.h itself is. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_STRINGMAPENTRY_H #define LLVM_ADT_STRINGMAPENTRY_H llvm/include/llvm/ADT/StringRef.h //===- StringRef.h - Constant String Reference Wrapper ----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_STRINGREF_H #define LLVM_ADT_STRINGREF_H llvm/include/llvm/ADT/StringSet.h //===- StringSet.h - An efficient set built on StringMap --------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// StringSet - A set-like wrapper for the StringMap. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_STRINGSET_H #define LLVM_ADT_STRINGSET_H llvm/include/llvm/ADT/StringSwitch.h //===--- StringSwitch.h - Switch-on-literal-string Construct --------------===/ // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception //===----------------------------------------------------------------------===/ /// /// \file /// 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 llvm/include/llvm/ADT/StringTable.h //===- StringTable.h - Table of strings tracked by offset ----------C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_STRING_TABLE_H #define LLVM_ADT_STRING_TABLE_H llvm/include/llvm/ADT/TinyPtrVector.h //===- llvm/ADT/TinyPtrVector.h - 'Normally tiny' vectors -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_TINYPTRVECTOR_H #define LLVM_ADT_TINYPTRVECTOR_H llvm/include/llvm/ADT/TrieHashIndexGenerator.h //===- TrieHashIndexGenerator.h ---------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_TRIEHASHINDEXGENERATOR_H #define LLVM_ADT_TRIEHASHINDEXGENERATOR_H llvm/include/llvm/ADT/TrieRawHashMap.h //===- TrieRawHashMap.h -----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_TRIERAWHASHMAP_H #define LLVM_ADT_TRIERAWHASHMAP_H llvm/include/llvm/ADT/Twine.h //===- Twine.h - Fast Temporary String Concatenation ------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_TWINE_H #define LLVM_ADT_TWINE_H llvm/include/llvm/ADT/TypeSwitch.h //===- TypeSwitch.h - Switch functionality for RTTI casting -*- C++ -*-----===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file implements the TypeSwitch template, which mimics a switch() /// statement whose cases are type names. /// //===-----------------------------------------------------------------------===/ #ifndef LLVM_ADT_TYPESWITCH_H #define LLVM_ADT_TYPESWITCH_H llvm/include/llvm/ADT/UniqueVector.h //===- llvm/ADT/UniqueVector.h ----------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_UNIQUEVECTOR_H #define LLVM_ADT_UNIQUEVECTOR_H llvm/include/llvm/ADT/bit.h //===-- llvm/ADT/bit.h - C++20 ----------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file implements the C++20 header. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_BIT_H #define LLVM_ADT_BIT_H llvm/include/llvm/ADT/edit_distance.h //===-- llvm/ADT/edit_distance.h - Array edit distance function --- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/fallible_iterator.h //===--- fallible_iterator.h - Wrapper for fallible iterators ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_FALLIBLE_ITERATOR_H #define LLVM_ADT_FALLIBLE_ITERATOR_H llvm/include/llvm/ADT/ilist.h //==-- llvm/ADT/ilist.h - Intrusive Linked List Template ---------*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 class itself should be a plug in replacement for list. 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 as a circular list. The list itself contains /// a sentinel node, whose Next points at begin() and whose Prev points at /// rbegin(). The sentinel node itself serves as end() and rend(). /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ILIST_H #define LLVM_ADT_ILIST_H llvm/include/llvm/ADT/ilist_base.h //===- llvm/ADT/ilist_base.h - Intrusive List Base --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ILIST_BASE_H #define LLVM_ADT_ILIST_BASE_H llvm/include/llvm/ADT/ilist_iterator.h //===- llvm/ADT/ilist_iterator.h - Intrusive List Iterator ------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ILIST_ITERATOR_H #define LLVM_ADT_ILIST_ITERATOR_H llvm/include/llvm/ADT/ilist_node.h //===- llvm/ADT/ilist_node.h - Intrusive Linked List Helper -----*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// 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 llvm/include/llvm/ADT/ilist_node_base.h //===- llvm/ADT/ilist_node_base.h - Intrusive List Node Base -----*- C++ -*-==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ILIST_NODE_BASE_H #define LLVM_ADT_ILIST_NODE_BASE_H llvm/include/llvm/ADT/ilist_node_options.h //===- llvm/ADT/ilist_node_options.h - ilist_node Options -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ILIST_NODE_OPTIONS_H #define LLVM_ADT_ILIST_NODE_OPTIONS_H llvm/include/llvm/ADT/iterator.h //===- iterator.h - Utilities for using and defining iterators --*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ITERATOR_H #define LLVM_ADT_ITERATOR_H llvm/include/llvm/ADT/iterator_range.h //===- iterator_range.h - A range adaptor for iterators ---------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// \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. /// //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_ITERATOR_RANGE_H #define LLVM_ADT_ITERATOR_RANGE_H llvm/include/llvm/ADT/simple_ilist.h //===- llvm/ADT/simple_ilist.h - Simple Intrusive List ----------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_SIMPLE_ILIST_H #define LLVM_ADT_SIMPLE_ILIST_H llvm/include/llvm/Demangle/Demangle.h //===--- Demangle.h ---------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_DEMANGLE_DEMANGLE_H #define LLVM_DEMANGLE_DEMANGLE_H llvm/include/llvm/Demangle/DemangleConfig.h //===--- DemangleConfig.h ---------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains a variety of feature test macros copied from // include/llvm/Support/Compiler.h so that LLVMDemangle does not need to take // a dependency on LLVMSupport. // //===----------------------------------------------------------------------===// #ifndef LLVM_DEMANGLE_DEMANGLECONFIG_H #define LLVM_DEMANGLE_DEMANGLECONFIG_H #ifndef __has_feature #define __has_feature(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_builtin #define __has_builtin(x) 0 #endif #ifndef DEMANGLE_GNUC_PREREQ #if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) #define DEMANGLE_GNUC_PREREQ(maj, min, patch) \ ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \ ((maj) << 20) + ((min) << 10) + (patch)) #elif defined(__GNUC__) && defined(__GNUC_MINOR__) #define DEMANGLE_GNUC_PREREQ(maj, min, patch) \ ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10)) #else #define DEMANGLE_GNUC_PREREQ(maj, min, patch) 0 #endif #endif #if __has_attribute(used) || DEMANGLE_GNUC_PREREQ(3, 1, 0) #define DEMANGLE_ATTRIBUTE_USED __attribute__((__used__)) #else #define DEMANGLE_ATTRIBUTE_USED #endif #if __has_builtin(__builtin_unreachable) || DEMANGLE_GNUC_PREREQ(4, 5, 0) #define DEMANGLE_UNREACHABLE __builtin_unreachable() #elif defined(_MSC_VER) #define DEMANGLE_UNREACHABLE __assume(false) #else #define DEMANGLE_UNREACHABLE #endif #if __has_attribute(noinline) || DEMANGLE_GNUC_PREREQ(3, 4, 0) #define DEMANGLE_ATTRIBUTE_NOINLINE __attribute__((noinline)) #elif defined(_MSC_VER) #define DEMANGLE_ATTRIBUTE_NOINLINE __declspec(noinline) #else #define DEMANGLE_ATTRIBUTE_NOINLINE #endif #if !defined(NDEBUG) #define DEMANGLE_DUMP_METHOD DEMANGLE_ATTRIBUTE_NOINLINE DEMANGLE_ATTRIBUTE_USED #else #define DEMANGLE_DUMP_METHOD DEMANGLE_ATTRIBUTE_NOINLINE #endif #if __cplusplus > 201402L && __has_cpp_attribute(fallthrough) #define DEMANGLE_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define DEMANGLE_FALLTHROUGH [[gnu::fallthrough]] #elif !__cplusplus // Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious // error when __has_cpp_attribute is given a scoped attribute in C mode. #define DEMANGLE_FALLTHROUGH #elif __has_cpp_attribute(clang::fallthrough) #define DEMANGLE_FALLTHROUGH [[clang::fallthrough]] #else #define DEMANGLE_FALLTHROUGH #endif #ifndef DEMANGLE_ASSERT llvm/include/llvm/Demangle/ItaniumDemangle.h //===--- ItaniumDemangle.h -----------*- mode:c++;eval:(read-only-mode) -*-===// // Do not edit! See README.txt. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Generic itanium demangler library. // There are two copies of this file in the source tree. The one under // libcxxabi is the original and the one under llvm is the copy. Use // cp-to-llvm.sh to update the copy. See README.txt for more details. // //===----------------------------------------------------------------------===// #ifndef DEMANGLE_ITANIUMDEMANGLE_H #define DEMANGLE_ITANIUMDEMANGLE_H llvm/include/llvm/Demangle/MicrosoftDemangle.h //===------------------------- MicrosoftDemangle.h --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_DEMANGLE_MICROSOFTDEMANGLE_H #define LLVM_DEMANGLE_MICROSOFTDEMANGLE_H llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h //===- MicrosoftDemangleNodes.h ---------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines the AST nodes used in the MSVC demangler. // //===----------------------------------------------------------------------===// #ifndef LLVM_DEMANGLE_MICROSOFTDEMANGLENODES_H #define LLVM_DEMANGLE_MICROSOFTDEMANGLENODES_H llvm/include/llvm/Demangle/StringViewExtras.h //===--- StringViewExtras.h ----------*- mode:c++;eval:(read-only-mode) -*-===// // Do not edit! See README.txt. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // There are two copies of this file in the source tree. The one under // libcxxabi is the original and the one under llvm is the copy. Use // cp-to-llvm.sh to update the copy. See README.txt for more details. // //===----------------------------------------------------------------------===// #ifndef DEMANGLE_STRINGVIEW_H #define DEMANGLE_STRINGVIEW_H llvm/include/llvm/Demangle/Utility.h //===--- Utility.h -------------------*- mode:c++;eval:(read-only-mode) -*-===// // Do not edit! See README.txt. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Provide some utility classes for use in the demangler. // There are two copies of this file in the source tree. The one in libcxxabi // is the original and the one in llvm is the copy. Use cp-to-llvm.sh to update // the copy. See README.txt for more details. // //===----------------------------------------------------------------------===// #ifndef DEMANGLE_UTILITY_H #define DEMANGLE_UTILITY_H upstream/emscripten/system/lib/al.c /* * Copyright 2017 The Emscripten Authors. All rights reserved. * Emscripten is available under two separate licenses, the MIT license and the * University of Illinois/NCSA Open Source License. Both these licenses can be * found in the LICENSE file. */ // AL proc address retrieval upstream/emscripten/system/lib/compiler-rt/emscripten_exception_builtins.c /* * Copyright 2018 The Emscripten Authors. All rights reserved. * Emscripten is available under two separate licenses, the MIT license and the * University of Illinois/NCSA Open Source License. Both these licenses can be * found in the LICENSE file. * * Support functions for emscripten setjmp/longjmp and exception handling * support. References to the things below are generated in the LLVM backend. * See: https://llvm.org/doxygen/WebAssemblyLowerEmscriptenEHSjLj_8cpp.html */ upstream/emscripten/system/lib/compiler-rt/emscripten_setjmp.c /* * Copyright 2020 The Emscripten Authors. All rights reserved. * Emscripten is available under two separate licenses, the MIT license and the * University of Illinois/NCSA Open Source License. Both these licenses can be * found in the LICENSE file. */ upstream/emscripten/system/lib/compiler-rt/include/sanitizer/allocator_interface.h //===-- allocator_interface.h ---------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Public interface header for allocator used in sanitizers (ASan/TSan/MSan). //===----------------------------------------------------------------------===// #ifndef SANITIZER_ALLOCATOR_INTERFACE_H #define SANITIZER_ALLOCATOR_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/asan_interface.h //===-- sanitizer/asan_interface.h ------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer (ASan). // // Public interface header. //===----------------------------------------------------------------------===// #ifndef SANITIZER_ASAN_INTERFACE_H #define SANITIZER_ASAN_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/common_interface_defs.h //===-- sanitizer/common_interface_defs.h -----------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Common part of the public sanitizer interface. //===----------------------------------------------------------------------===// #ifndef SANITIZER_COMMON_INTERFACE_DEFS_H #define SANITIZER_COMMON_INTERFACE_DEFS_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/coverage_interface.h //===-- sanitizer/coverage_interface.h --------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Public interface for sanitizer coverage. //===----------------------------------------------------------------------===// #ifndef SANITIZER_COVERAG_INTERFACE_H #define SANITIZER_COVERAG_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/dfsan_interface.h //===-- dfsan_interface.h -------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of DataFlowSanitizer. // // Public interface header. //===----------------------------------------------------------------------===// #ifndef DFSAN_INTERFACE_H #define DFSAN_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/hwasan_interface.h //===-- sanitizer/hwasan_interface.h ----------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of HWAddressSanitizer. // // Public interface header. //===----------------------------------------------------------------------===// #ifndef SANITIZER_HWASAN_INTERFACE_H #define SANITIZER_HWASAN_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/lsan_interface.h //===-- sanitizer/lsan_interface.h ------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of LeakSanitizer. // // Public interface header. //===----------------------------------------------------------------------===// #ifndef SANITIZER_LSAN_INTERFACE_H #define SANITIZER_LSAN_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/memprof_interface.h //===-- sanitizer/memprof_interface.h --------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of MemProfiler (MemProf). // // Public interface header. //===----------------------------------------------------------------------===// #ifndef SANITIZER_MEMPROF_INTERFACE_H #define SANITIZER_MEMPROF_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/msan_interface.h //===-- msan_interface.h --------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of MemorySanitizer. // // Public interface header. //===----------------------------------------------------------------------===// #ifndef MSAN_INTERFACE_H #define MSAN_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/nsan_interface.h //===-- sanitizer/nsan_interface.h ------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Public interface for nsan. // //===----------------------------------------------------------------------===// #ifndef SANITIZER_NSAN_INTERFACE_H #define SANITIZER_NSAN_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/rtsan_interface.h //===-- sanitizer/rtsan_interface.h -----------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of RealtimeSanitizer. // // Public interface header. //===----------------------------------------------------------------------===// #ifndef SANITIZER_RTSAN_INTERFACE_H #define SANITIZER_RTSAN_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/scudo_interface.h //===-- sanitizer/scudo_interface.h -----------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // /// Public Scudo interface header. // //===----------------------------------------------------------------------===// #ifndef SANITIZER_SCUDO_INTERFACE_H_ #define SANITIZER_SCUDO_INTERFACE_H_ upstream/emscripten/system/lib/compiler-rt/include/sanitizer/tsan_interface.h //===-- tsan_interface.h ----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of ThreadSanitizer (TSan), a race detector. // // Public interface header for TSan. //===----------------------------------------------------------------------===// #ifndef SANITIZER_TSAN_INTERFACE_H #define SANITIZER_TSAN_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/tsan_interface_atomic.h //===-- tsan_interface_atomic.h ---------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of ThreadSanitizer (TSan), a race detector. // // Public interface header for TSan atomics. //===----------------------------------------------------------------------===// #ifndef TSAN_INTERFACE_ATOMIC_H #define TSAN_INTERFACE_ATOMIC_H upstream/emscripten/system/lib/compiler-rt/include/sanitizer/ubsan_interface.h //===-- sanitizer/ubsan_interface.h -----------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of UBSanitizer (UBSan). // // Public interface header. //===----------------------------------------------------------------------===// #ifndef SANITIZER_UBSAN_INTERFACE_H #define SANITIZER_UBSAN_INTERFACE_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_activation.cpp //===-- asan_activation.cpp -------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan activation/deactivation logic. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_aix.cpp //===-- asan_aix.cpp ------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // AIX-specific details. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_allocator.cpp //===-- asan_allocator.cpp ------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Implementation of ASan's memory allocator, 2-nd version. // This variant uses the allocator from sanitizer_common, i.e. the one shared // with ThreadSanitizer and MemorySanitizer. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_allocator.h //===-- asan_allocator.h ----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header for asan_allocator.cpp. //===----------------------------------------------------------------------===// #ifndef ASAN_ALLOCATOR_H #define ASAN_ALLOCATOR_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_debugging.cpp //===-- asan_debugging.cpp ------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // This file contains various functions that are generally useful to call when // using a debugger (LLDB, GDB). //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_descriptions.cpp //===-- asan_descriptions.cpp -----------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan functions for getting information about an address and/or printing it. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_descriptions.h //===-- asan_descriptions.h -------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header for asan_descriptions.cpp. // TODO(filcab): Most struct definitions should move to the interface headers. //===----------------------------------------------------------------------===// #ifndef ASAN_DESCRIPTIONS_H #define ASAN_DESCRIPTIONS_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_errors.cpp //===-- asan_errors.cpp -----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan implementation for error structures. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_errors.h //===-- asan_errors.h -------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header for error structures. //===----------------------------------------------------------------------===// #ifndef ASAN_ERRORS_H #define ASAN_ERRORS_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_fake_stack.cpp //===-- asan_fake_stack.cpp -----------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // FakeStack is used to detect use-after-return bugs. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_fake_stack.h //===-- asan_fake_stack.h ---------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header for asan_fake_stack.cpp, implements FakeStack. //===----------------------------------------------------------------------===// #ifndef ASAN_FAKE_STACK_H #define ASAN_FAKE_STACK_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_flags.cpp //===-- asan_flags.cpp ------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan flag parsing logic. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_flags.h //===-- asan_flags.h -------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan runtime flags. //===----------------------------------------------------------------------===// #ifndef ASAN_FLAGS_H #define ASAN_FLAGS_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_fuchsia.cpp //===-- asan_fuchsia.cpp -------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===---------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Fuchsia-specific details. //===---------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_globals.cpp //===-- asan_globals.cpp --------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Handle globals. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_globals_win.cpp //===-- asan_globals_win.cpp ----------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Global registration code that is linked into every Windows DLL and EXE. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_init_version.h //===-- asan_init_version.h -------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // This header defines a versioned __asan_init function to be called at the // startup of the instrumented program. //===----------------------------------------------------------------------===// #ifndef ASAN_INIT_VERSION_H #define ASAN_INIT_VERSION_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_interceptors.cpp //===-- asan_interceptors.cpp ---------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Intercept various libc functions. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_interceptors.h //===-- asan_interceptors.h -------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header for asan_interceptors.cpp //===----------------------------------------------------------------------===// #ifndef ASAN_INTERCEPTORS_H #define ASAN_INTERCEPTORS_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_interceptors_memintrinsics.cpp //===-- asan_interceptors_memintrinsics.cpp -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===---------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan versions of memcpy, memmove, and memset. //===---------------------------------------------------------------------===// #define SANITIZER_COMMON_NO_REDEFINE_BUILTINS upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_interceptors_memintrinsics.h //===-- asan_interceptors_memintrinsics.h -----------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===---------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header for asan_interceptors_memintrinsics.cpp //===---------------------------------------------------------------------===// #ifndef ASAN_MEMINTRIN_H #define ASAN_MEMINTRIN_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_interface_internal.h //===-- asan_interface_internal.h -------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // This header declares the AddressSanitizer runtime interface functions. // The runtime library has to define these functions so the instrumented program // could call them. // // See also include/sanitizer/asan_interface.h //===----------------------------------------------------------------------===// #ifndef ASAN_INTERFACE_INTERNAL_H #define ASAN_INTERFACE_INTERNAL_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_internal.h //===-- asan_internal.h -----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header which defines various general utilities. //===----------------------------------------------------------------------===// #ifndef ASAN_INTERNAL_H #define ASAN_INTERNAL_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_linux.cpp //===-- asan_linux.cpp ----------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Linux-specific details. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_mac.cpp //===-- asan_mac.cpp ------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Mac-specific details. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_malloc_linux.cpp //===-- asan_malloc_linux.cpp ---------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Linux-specific malloc interception. // We simply define functions like malloc, free, realloc, etc. // They will replace the corresponding libc functions automagically. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_malloc_mac.cpp //===-- asan_malloc_mac.cpp -----------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Mac-specific malloc interception. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_malloc_win.cpp //===-- asan_malloc_win.cpp -----------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Windows-specific malloc interception. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_malloc_win_thunk.cpp //===-- asan_malloc_win_thunk.cpp //-----------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Windows-specific malloc interception. // This is included statically for projects statically linking // with the C Runtime (/MT, /MTd) in order to provide ASAN-aware // versions of the C allocation functions. //===----------------------------------------------------------------------===// #ifdef SANITIZER_STATIC_RUNTIME_THUNK # include "..\sanitizer_common\sanitizer_allocator_interface.h" // upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_mapping.h //===-- asan_mapping.h ------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Defines ASan memory mapping. //===----------------------------------------------------------------------===// #ifndef ASAN_MAPPING_H #define ASAN_MAPPING_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_memory_profile.cpp //===-- asan_memory_profile.cpp ----------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // This file implements __sanitizer_print_memory_profile. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_new_delete.cpp //===-- asan_interceptors.cpp ---------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Interceptors for operators new and delete. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_poisoning.cpp //===-- asan_poisoning.cpp ------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Shadow memory poisoning by ASan RTL and by user application. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_poisoning.h //===-- asan_poisoning.h ----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Shadow memory poisoning by ASan RTL and by user application. //===----------------------------------------------------------------------===// #ifndef ASAN_POISONING_H #define ASAN_POISONING_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_posix.cpp //===-- asan_posix.cpp ----------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Posix-specific details. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_preinit.cpp //===-- asan_preinit.cpp --------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Call __asan_init at the very early stage of process startup. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_premap_shadow.cpp //===-- asan_premap_shadow.cpp --------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Reserve shadow memory with an ifunc resolver. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_report.cpp //===-- asan_report.cpp ---------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // This file contains error reporting code. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_report.h //===-- asan_report.h -------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header for error reporting functions. //===----------------------------------------------------------------------===// #ifndef ASAN_REPORT_H #define ASAN_REPORT_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_rtl.cpp //===-- asan_rtl.cpp ------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Main file of the ASan run-time library. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_rtl_static.cpp //===-- asan_static_rtl.cpp -----------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Main file of the ASan run-time library. //===----------------------------------------------------------------------===// // This file is empty for now. Main reason to have it is workaround for Windows // build, which complains because no files are part of the asan_static lib. upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_scariness_score.h //===-- asan_scariness_score.h ----------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Compute the level of scariness of the error message. // Don't expect any deep science here, just a set of heuristics that suggest // that e.g. 1-byte-read-global-buffer-overflow is less scary than // 8-byte-write-stack-use-after-return. // // Every error report has one or more features, such as memory access size, // type (read or write), type of accessed memory (e.g. free-d heap, or a global // redzone), etc. Every such feature has an int score and a string description. // The overall score is the sum of all feature scores and the description // is a concatenation of feature descriptions. // Examples: // 17 (4-byte-read-heap-buffer-overflow) // 65 (multi-byte-write-stack-use-after-return) // 10 (null-deref) // //===----------------------------------------------------------------------===// #ifndef ASAN_SCARINESS_SCORE_H #define ASAN_SCARINESS_SCORE_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_shadow_setup.cpp //===-- asan_shadow_setup.cpp ---------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Set up the shadow memory. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_stack.cpp //===-- asan_stack.cpp ----------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Code for ASan stack trace. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_stack.h //===-- asan_stack.h --------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header for asan_stack.cpp. //===----------------------------------------------------------------------===// #ifndef ASAN_STACK_H #define ASAN_STACK_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_stats.cpp //===-- asan_stats.cpp ----------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Code related to statistics collected by AddressSanitizer. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_stats.h //===-- asan_stats.h --------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header for statistics. //===----------------------------------------------------------------------===// #ifndef ASAN_STATS_H #define ASAN_STATS_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_suppressions.cpp //===-- asan_suppressions.cpp ---------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Issue suppression and suppression-related functions. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_suppressions.h //===-- asan_suppressions.h -------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header for asan_suppressions.cpp. //===----------------------------------------------------------------------===// #ifndef ASAN_SUPPRESSIONS_H #define ASAN_SUPPRESSIONS_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_thread.cpp //===-- asan_thread.cpp ---------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Thread-related code. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_thread.h //===-- asan_thread.h -------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // ASan-private header for asan_thread.cpp. //===----------------------------------------------------------------------===// #ifndef ASAN_THREAD_H #define ASAN_THREAD_H upstream/emscripten/system/lib/compiler-rt/lib/asan/asan_win.cpp //===-- asan_win.cpp //------------------------------------------------------===//> // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Windows-specific details. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/absvdi2.c //===-- absvdi2.c - Implement __absvdi2 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __absvdi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/absvsi2.c //===-- absvsi2.c - Implement __absvsi2 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __absvsi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/absvti2.c //===-- absvti2.c - Implement __absvdi2 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __absvti2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/adddf3.c //===-- lib/adddf3.c - Double-precision addition ------------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements double-precision soft-float addition. // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/addsf3.c //===-- lib/addsf3.c - Single-precision addition ------------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements single-precision soft-float addition. // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/addtf3.c //===-- lib/addtf3.c - Quad-precision addition --------------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements quad-precision soft-float addition. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/addvdi3.c //===-- addvdi3.c - Implement __addvdi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __addvdi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/addvsi3.c //===-- addvsi3.c - Implement __addvsi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __addvsi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/addvti3.c //===-- addvti3.c - Implement __addvti3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __addvti3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/apple_versioning.c //===-- apple_versioning.c - Adds versioning symbols for ld ---------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #if __APPLE__ upstream/emscripten/system/lib/compiler-rt/lib/builtins/ashldi3.c // ====-- ashldi3.c - Implement __ashldi3 ---------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ashldi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/ashlti3.c //===-- ashlti3.c - Implement __ashlti3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ashlti3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/ashrdi3.c //===-- ashrdi3.c - Implement __ashrdi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ashrdi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/ashrti3.c //===-- ashrti3.c - Implement __ashrti3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ashrti3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/assembly.h //===-- assembly.h - compiler-rt assembler support macros -----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file defines macros for use in compiler-rt assembler source. // This file is not part of the interface of this library. // //===----------------------------------------------------------------------===// #ifndef COMPILERRT_ASSEMBLY_H #define COMPILERRT_ASSEMBLY_H #ifdef __CET__ #if __has_include() upstream/emscripten/system/lib/compiler-rt/lib/builtins/atomic.c //===-- atomic.c - Implement support functions for atomic operations.------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // atomic.c defines a set of functions for performing atomic accesses on // arbitrary-sized memory locations. This design uses locks that should // be fast in the uncontended case, for two reasons: // // 1) This code must work with C programs that do not link to anything // (including pthreads) and so it should not depend on any pthread // functions. If the user wishes to opt into using pthreads, they may do so. // 2) Atomic operations, rather than explicit mutexes, are most commonly used // on code where contended operations are rate. // // To avoid needing a per-object lock, this code allocates an array of // locks and hashes the object pointers to find the one that it should use. // For operations that must be atomic on two locations, the lower lock is // always acquired first, to avoid deadlock. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/atomic_flag_clear.c //===-- atomic_flag_clear.c -----------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements atomic_flag_clear from C11's stdatomic.h. // //===----------------------------------------------------------------------===// #ifndef __has_include #define __has_include(inc) 0 #endif #if __has_include() upstream/emscripten/system/lib/compiler-rt/lib/builtins/atomic_flag_clear_explicit.c //===-- atomic_flag_clear_explicit.c --------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements atomic_flag_clear_explicit from C11's stdatomic.h. // //===----------------------------------------------------------------------===// #ifndef __has_include #define __has_include(inc) 0 #endif #if __has_include() upstream/emscripten/system/lib/compiler-rt/lib/builtins/atomic_flag_test_and_set.c //===-- atomic_flag_test_and_set.c ----------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements atomic_flag_test_and_set from C11's stdatomic.h. // //===----------------------------------------------------------------------===// #ifndef __has_include #define __has_include(inc) 0 #endif #if __has_include() upstream/emscripten/system/lib/compiler-rt/lib/builtins/atomic_flag_test_and_set_explicit.c //===-- atomic_flag_test_and_set_explicit.c -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements atomic_flag_test_and_set_explicit from C11's stdatomic.h // //===----------------------------------------------------------------------===// #ifndef __has_include #define __has_include(inc) 0 #endif #if __has_include() upstream/emscripten/system/lib/compiler-rt/lib/builtins/atomic_signal_fence.c //===-- atomic_signal_fence.c ---------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements atomic_signal_fence from C11's stdatomic.h. // //===----------------------------------------------------------------------===// #ifndef __has_include #define __has_include(inc) 0 #endif #if __has_include() upstream/emscripten/system/lib/compiler-rt/lib/builtins/atomic_thread_fence.c //===-- atomic_thread_fence.c ---------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements atomic_thread_fence from C11's stdatomic.h. // //===----------------------------------------------------------------------===// #ifndef __has_include #define __has_include(inc) 0 #endif #if __has_include() upstream/emscripten/system/lib/compiler-rt/lib/builtins/bswapdi2.c //===-- bswapdi2.c - Implement __bswapdi2 ---------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __bswapdi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/bswapsi2.c //===-- bswapsi2.c - Implement __bswapsi2 ---------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __bswapsi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/clear_cache.c //===-- clear_cache.c - Implement __clear_cache ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/clzdi2.c //===-- clzdi2.c - Implement __clzdi2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __clzdi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/clzsi2.c //===-- clzsi2.c - Implement __clzsi2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __clzsi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/clzti2.c //===-- clzti2.c - Implement __clzti2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __clzti2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/cmpdi2.c //===-- cmpdi2.c - Implement __cmpdi2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __cmpdi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/cmpti2.c //===-- cmpti2.c - Implement __cmpti2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __cmpti2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/comparedf2.c //===-- lib/comparedf2.c - Double-precision comparisons -----------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // // This file implements the following soft-float comparison routines: // // __eqdf2 __gedf2 __unorddf2 // __ledf2 __gtdf2 // __ltdf2 // __nedf2 // // The semantics of the routines grouped in each column are identical, so there // is a single implementation for each, and wrappers to provide the other names. // // The main routines behave as follows: // // __ledf2(a,b) returns -1 if a < b // 0 if a == b // 1 if a > b // 1 if either a or b is NaN // // __gedf2(a,b) returns -1 if a < b // 0 if a == b // 1 if a > b // -1 if either a or b is NaN // // __unorddf2(a,b) returns 0 if both a and b are numbers // 1 if either a or b is NaN // // Note that __ledf2( ) and __gedf2( ) are identical except in their handling of // NaN values. // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/comparesf2.c //===-- lib/comparesf2.c - Single-precision comparisons -----------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the following soft-fp_t comparison routines: // // __eqsf2 __gesf2 __unordsf2 // __lesf2 __gtsf2 // __ltsf2 // __nesf2 // // The semantics of the routines grouped in each column are identical, so there // is a single implementation for each, and wrappers to provide the other names. // // The main routines behave as follows: // // __lesf2(a,b) returns -1 if a < b // 0 if a == b // 1 if a > b // 1 if either a or b is NaN // // __gesf2(a,b) returns -1 if a < b // 0 if a == b // 1 if a > b // -1 if either a or b is NaN // // __unordsf2(a,b) returns 0 if both a and b are numbers // 1 if either a or b is NaN // // Note that __lesf2( ) and __gesf2( ) are identical except in their handling of // NaN values. // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/comparetf2.c //===-- lib/comparetf2.c - Quad-precision comparisons -------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // // This file implements the following soft-float comparison routines: // // __eqtf2 __getf2 __unordtf2 // __letf2 __gttf2 // __lttf2 // __netf2 // // The semantics of the routines grouped in each column are identical, so there // is a single implementation for each, and wrappers to provide the other names. // // The main routines behave as follows: // // __letf2(a,b) returns -1 if a < b // 0 if a == b // 1 if a > b // 1 if either a or b is NaN // // __getf2(a,b) returns -1 if a < b // 0 if a == b // 1 if a > b // -1 if either a or b is NaN // // __unordtf2(a,b) returns 0 if both a and b are numbers // 1 if either a or b is NaN // // Note that __letf2( ) and __getf2( ) are identical except in their handling of // NaN values. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/crtbegin.c //===-- crtbegin.c - Start of constructors and destructors ----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/crtend.c //===-- crtend.c - End of constructors and destructors --------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/ctzdi2.c //===-- ctzdi2.c - Implement __ctzdi2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ctzdi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/ctzsi2.c //===-- ctzsi2.c - Implement __ctzsi2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ctzsi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/ctzti2.c //===-- ctzti2.c - Implement __ctzti2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ctzti2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/divdc3.c //===-- divdc3.c - Implement __divdc3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __divdc3 for the compiler_rt library. // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/divdf3.c //===-- lib/divdf3.c - Double-precision division ------------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements double-precision soft-float division // with the IEEE-754 default rounding (to nearest, ties to even). // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION #define NUMBER_OF_HALF_ITERATIONS 3 #define NUMBER_OF_FULL_ITERATIONS 1 upstream/emscripten/system/lib/compiler-rt/lib/builtins/divdi3.c //===-- divdi3.c - Implement __divdi3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __divdi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/divmoddi4.c //===-- divmoddi4.c - Implement __divmoddi4 -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __divmoddi4 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/divmodsi4.c //===-- divmodsi4.c - Implement __divmodsi4 //--------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __divmodsi4 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/divmodti4.c //===-- divmodti4.c - Implement __divmodti4 -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __divmodti4 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/divsc3.c //===-- divsc3.c - Implement __divsc3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __divsc3 for the compiler_rt library. // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/divsf3.c //===-- lib/divsf3.c - Single-precision division ------------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements single-precision soft-float division // with the IEEE-754 default rounding (to nearest, ties to even). // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION #define NUMBER_OF_HALF_ITERATIONS 0 #define NUMBER_OF_FULL_ITERATIONS 3 #define USE_NATIVE_FULL_ITERATIONS upstream/emscripten/system/lib/compiler-rt/lib/builtins/divsi3.c //===-- divsi3.c - Implement __divsi3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __divsi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/divtc3.c //===-- divtc3.c - Implement __divtc3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __divtc3 for the compiler_rt library. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/divtf3.c //===-- lib/divtf3.c - Quad-precision division --------------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements quad-precision soft-float division // with the IEEE-754 default rounding (to nearest, ties to even). // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/divti3.c //===-- divti3.c - Implement __divti3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __divti3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/divxc3.c //===-- divxc3.c - Implement __divxc3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __divxc3 for the compiler_rt library. // //===----------------------------------------------------------------------===// #if !_ARCH_PPC upstream/emscripten/system/lib/compiler-rt/lib/builtins/emutls.c //===---------- emutls.c - Implements __emutls_get_address ---------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/enable_execute_stack.c //===-- enable_execute_stack.c - Implement __enable_execute_stack ---------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/eprintf.c //===---------- eprintf.c - Implements __eprintf --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/extendbfsf2.c //===-- lib/extendbfsf2.c - bfloat -> single conversion -----------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SRC_BFLOAT16 #define DST_SINGLE upstream/emscripten/system/lib/compiler-rt/lib/builtins/extenddftf2.c //===-- lib/extenddftf2.c - double -> quad conversion -------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/extendhfdf2.c //===-- lib/extendhfdf2.c - half -> single conversion -------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SRC_HALF #define DST_DOUBLE upstream/emscripten/system/lib/compiler-rt/lib/builtins/extendhfsf2.c //===-- lib/extendhfsf2.c - half -> single conversion -------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SRC_HALF #define DST_SINGLE upstream/emscripten/system/lib/compiler-rt/lib/builtins/extendhftf2.c //===-- lib/extendhftf2.c - half -> quad conversion ---------------*- C -*-===// // // The LLVM Compiler Infrastructure // // This file is dual licensed under the MIT and the University of Illinois Open // Source Licenses. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/extendhfxf2.c //===-- lib/extendhfxf2.c - half -> long double conversion --------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/extendsfdf2.c //===-- lib/extendsfdf2.c - single -> double conversion -----------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SRC_SINGLE #define DST_DOUBLE upstream/emscripten/system/lib/compiler-rt/lib/builtins/extendsftf2.c //===-- lib/extendsftf2.c - single -> quad conversion -------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/extendxftf2.c //===-- lib/extendxftf2.c - long double -> quad conversion --------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // Assumption: long double is a IEEE 80 bit floating point type padded to 128 // bits. #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/ffsdi2.c //===-- ffsdi2.c - Implement __ffsdi2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ffsdi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/ffssi2.c //===-- ffssi2.c - Implement __ffssi2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ffssi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/ffsti2.c //===-- ffsti2.c - Implement __ffsti2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ffsti2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixdfdi.c //===-- fixdfdi.c - Implement __fixdfdi -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixdfsi.c //===-- fixdfsi.c - Implement __fixdfsi -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixdfti.c //===-- fixdfti.c - Implement __fixdfti -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixsfdi.c //===-- fixsfdi.c - Implement __fixsfdi -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixsfsi.c //===-- fixsfsi.c - Implement __fixsfsi -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixsfti.c //===-- fixsfti.c - Implement __fixsfti -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixtfdi.c //===-- fixtfdi.c - Implement __fixtfdi -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixtfsi.c //===-- fixtfsi.c - Implement __fixtfsi -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixtfti.c //===-- fixtfti.c - Implement __fixtfti -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunsdfdi.c //===-- fixunsdfdi.c - Implement __fixunsdfdi -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunsdfsi.c //===-- fixunsdfsi.c - Implement __fixunsdfsi -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunsdfti.c //===-- fixunsdfti.c - Implement __fixunsdfti -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunssfdi.c //===-- fixunssfdi.c - Implement __fixunssfdi -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunssfsi.c //===-- fixunssfsi.c - Implement __fixunssfsi -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __fixunssfsi for the compiler_rt library. // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunssfti.c //===-- fixunssfti.c - Implement __fixunssfti -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __fixunssfti for the compiler_rt library. // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunstfdi.c //===-- fixunstfdi.c - Implement __fixunstfdi -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunstfsi.c //===-- fixunstfsi.c - Implement __fixunstfsi -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunstfti.c //===-- fixunstfsi.c - Implement __fixunstfsi -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunsxfdi.c //===-- fixunsxfdi.c - Implement __fixunsxfdi -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __fixunsxfdi for the compiler_rt library. // //===----------------------------------------------------------------------===// #if !_ARCH_PPC upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunsxfsi.c //===-- fixunsxfsi.c - Implement __fixunsxfsi -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __fixunsxfsi for the compiler_rt library. // //===----------------------------------------------------------------------===// #if !_ARCH_PPC upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixunsxfti.c //===-- fixunsxfti.c - Implement __fixunsxfti -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __fixunsxfti for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixxfdi.c //===-- fixxfdi.c - Implement __fixxfdi -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __fixxfdi for the compiler_rt library. // //===----------------------------------------------------------------------===// #if !_ARCH_PPC upstream/emscripten/system/lib/compiler-rt/lib/builtins/fixxfti.c //===-- fixxfti.c - Implement __fixxfti -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __fixxfti for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatdidf.c //===-- floatdidf.c - Implement __floatdidf -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floatdidf for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatdisf.c //===-- floatdisf.c - Implement __floatdisf -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floatdisf for the compiler_rt library. // //===----------------------------------------------------------------------===// // Returns: convert a to a float, rounding toward even. // Assumption: float is a IEEE 32 bit floating point type // di_int is a 64 bit integral type // seee eeee emmm mmmm mmmm mmmm mmmm mmmm upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatditf.c //===-- lib/floatditf.c - integer -> quad-precision conversion ----*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements di_int to quad-precision conversion for the // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even // mode. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatdixf.c //===-- floatdixf.c - Implement __floatdixf -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floatdixf for the compiler_rt library. // //===----------------------------------------------------------------------===// #if !_ARCH_PPC upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatsidf.c //===-- lib/floatsidf.c - integer -> double-precision conversion --*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements integer to double-precision conversion for the // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even // mode. // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatsisf.c //===-- lib/floatsisf.c - integer -> single-precision conversion --*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements integer to single-precision conversion for the // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even // mode. // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatsitf.c //===-- lib/floatsitf.c - integer -> quad-precision conversion ----*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements integer to quad-precision conversion for the // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even // mode. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/floattidf.c //===-- floattidf.c - Implement __floattidf -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floattidf for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/floattisf.c //===-- floattisf.c - Implement __floattisf -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floattisf for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/floattitf.c //===-- lib/floattitf.c - int128 -> quad-precision conversion -----*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements ti_int to quad-precision conversion for the // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even // mode. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/floattixf.c //===-- floattixf.c - Implement __floattixf -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floattixf for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatundidf.c //===-- floatundidf.c - Implement __floatundidf ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floatundidf for the compiler_rt library. // //===----------------------------------------------------------------------===// // Returns: convert a to a double, rounding toward even. // Assumption: double is a IEEE 64 bit floating point type // du_int is a 64 bit integral type // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm // mmmm upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatundisf.c //===-- floatundisf.c - Implement __floatundisf ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floatundisf for the compiler_rt library. // //===----------------------------------------------------------------------===// // Returns: convert a to a float, rounding toward even. // Assumption: float is a IEEE 32 bit floating point type // du_int is a 64 bit integral type // seee eeee emmm mmmm mmmm mmmm mmmm mmmm upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatunditf.c //===-- lib/floatunditf.c - uint -> quad-precision conversion -----*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements du_int to quad-precision conversion for the // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even // mode. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatundixf.c //===-- floatundixf.c - Implement __floatundixf ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floatundixf for the compiler_rt library. // //===----------------------------------------------------------------------===// #if !_ARCH_PPC upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatunsidf.c //===-- lib/floatunsidf.c - uint -> double-precision conversion ---*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements unsigned integer to double-precision conversion for the // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even // mode. // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatunsisf.c //===-- lib/floatunsisf.c - uint -> single-precision conversion ---*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements unsigned integer to single-precision conversion for the // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even // mode. // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatunsitf.c //===-- lib/floatunsitf.c - uint -> quad-precision conversion -----*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements unsigned integer to quad-precision conversion for the // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even // mode. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatuntidf.c //===-- floatuntidf.c - Implement __floatuntidf ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floatuntidf for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatuntisf.c //===-- floatuntisf.c - Implement __floatuntisf ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floatuntisf for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatuntitf.c //===-- lib/floatuntitf.c - uint128 -> quad-precision conversion --*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements tu_int to quad-precision conversion for the // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even // mode. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/floatuntixf.c //===-- floatuntixf.c - Implement __floatuntixf ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __floatuntixf for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/fp_extend.h //===-lib/fp_extend.h - low precision -> high precision conversion -*- C //-*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Set source and destination setting // //===----------------------------------------------------------------------===// #ifndef FP_EXTEND_HEADER #define FP_EXTEND_HEADER upstream/emscripten/system/lib/compiler-rt/lib/builtins/fp_lib.h //===-- lib/fp_lib.h - Floating-point utilities -------------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a configuration header for soft-float routines in compiler-rt. // This file does not provide any part of the compiler-rt interface, but defines // many useful constants and utility routines that are used in the // implementation of the soft-float routines in compiler-rt. // // Assumes that float, double and long double correspond to the IEEE-754 // binary32, binary64 and binary 128 types, respectively, and that integer // endianness matches floating point endianness on the target platform. // //===----------------------------------------------------------------------===// #ifndef FP_LIB_HEADER #define FP_LIB_HEADER upstream/emscripten/system/lib/compiler-rt/lib/builtins/fp_mode.c //===----- lib/fp_mode.c - Floaing-point environment mode utilities --C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file provides a default implementation of fp_mode.h for architectures // that does not support or does not have an implementation of floating point // environment mode. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/fp_trunc.h //=== lib/fp_trunc.h - high precision -> low precision conversion *- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Set source and destination precision setting // //===----------------------------------------------------------------------===// #ifndef FP_TRUNC_HEADER #define FP_TRUNC_HEADER upstream/emscripten/system/lib/compiler-rt/lib/builtins/gcc_personality_v0.c //===-- gcc_personality_v0.c - Implement __gcc_personality_v0 -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/int_endianness.h //===-- int_endianness.h - configuration header for compiler-rt -----------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a configuration header for compiler-rt. // This file is not part of the interface of this library. // //===----------------------------------------------------------------------===// #ifndef INT_ENDIANNESS_H #define INT_ENDIANNESS_H #if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \ defined(__ORDER_LITTLE_ENDIAN__) // Clang and GCC provide built-in endianness definitions. #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ #define _YUGA_LITTLE_ENDIAN 0 #define _YUGA_BIG_ENDIAN 1 #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #define _YUGA_LITTLE_ENDIAN 1 #define _YUGA_BIG_ENDIAN 0 #endif // __BYTE_ORDER__ #else // Compilers other than Clang or GCC. #if defined(__SVR4) && defined(__sun) upstream/emscripten/system/lib/compiler-rt/lib/builtins/int_lib.h //===-- int_lib.h - configuration header for compiler-rt -----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a configuration header for compiler-rt. // This file is not part of the interface of this library. // //===----------------------------------------------------------------------===// #ifndef INT_LIB_H #define INT_LIB_H // Assumption: Signed integral is 2's complement. // Assumption: Right shift of signed negative is arithmetic shift. // Assumption: Endianness is little or big (not mixed). // ABI macro definitions #if __ARM_EABI__ #ifdef COMPILER_RT_ARMHF_TARGET #define COMPILER_RT_ABI #else #define COMPILER_RT_ABI __attribute__((__pcs__("aapcs"))) #endif #else #define COMPILER_RT_ABI #endif #define AEABI_RTABI __attribute__((__pcs__("aapcs"))) #if defined(_MSC_VER) && !defined(__clang__) #define ALWAYS_INLINE __forceinline #define NOINLINE __declspec(noinline) #define NORETURN __declspec(noreturn) #define UNUSED #else #define ALWAYS_INLINE __attribute__((always_inline)) #define NOINLINE __attribute__((noinline)) #define NORETURN __attribute__((noreturn)) #define UNUSED __attribute__((unused)) #endif #define STR(a) #a #define XSTR(a) STR(a) #define SYMBOL_NAME(name) XSTR(__USER_LABEL_PREFIX__) #name #if defined(__ELF__) || defined(__MINGW32__) || defined(__wasm__) || \ defined(_AIX) || defined(__CYGWIN__) #define COMPILER_RT_ALIAS(name, aliasname) \ COMPILER_RT_ABI __typeof(name) aliasname __attribute__((__alias__(#name))); #elif defined(__APPLE__) #if defined(VISIBILITY_HIDDEN) #define COMPILER_RT_ALIAS_VISIBILITY(name) \ __asm__(".private_extern " SYMBOL_NAME(name)); #else #define COMPILER_RT_ALIAS_VISIBILITY(name) #endif #define COMPILER_RT_ALIAS(name, aliasname) \ __asm__(".globl " SYMBOL_NAME(aliasname)); \ COMPILER_RT_ALIAS_VISIBILITY(aliasname) \ __asm__(SYMBOL_NAME(aliasname) " = " SYMBOL_NAME(name)); \ COMPILER_RT_ABI __typeof(name) aliasname; #elif defined(_WIN32) || defined(__UEFI__) #define COMPILER_RT_ALIAS(name, aliasname) #else #error Unsupported target #endif #if (defined(__FreeBSD__) || defined(__NetBSD__)) && \ (defined(_KERNEL) || defined(_STANDALONE)) // // Kernel and boot environment can't use normal headers, // so use the equivalent system headers. // NB: FreeBSD (and OpenBSD) deprecate machine/limits.h in // favour of sys/limits.h, so prefer the former, but fall // back on the latter if not available since NetBSD only has // the latter. // #if defined(__has_include) && __has_include() upstream/emscripten/system/lib/compiler-rt/lib/builtins/int_math.h //===-- int_math.h - internal math inlines --------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is not part of the interface of this library. // // This file defines substitutes for the libm functions used in some of the // compiler-rt implementations, defined in such a way that there is not a direct // dependency on libm or math.h. Instead, we use the compiler builtin versions // where available. This reduces our dependencies on the system SDK by foisting // the responsibility onto the compiler. // //===----------------------------------------------------------------------===// #ifndef INT_MATH_H #define INT_MATH_H #ifndef __has_builtin #define __has_builtin(x) 0 #endif #if defined(_MSC_VER) && !defined(__clang__) upstream/emscripten/system/lib/compiler-rt/lib/builtins/int_to_fp.h //===-- int_to_fp.h - integer to floating point conversion ----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Set source and destination defines in order to use a correctly // parameterised floatXiYf implementation. // //===----------------------------------------------------------------------===// #ifndef INT_TO_FP_H #define INT_TO_FP_H upstream/emscripten/system/lib/compiler-rt/lib/builtins/int_types.h //===-- int_lib.h - configuration header for compiler-rt -----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is not part of the interface of this library. // // This file defines various standard types, most importantly a number of unions // used to access parts of larger types. // //===----------------------------------------------------------------------===// #ifndef INT_TYPES_H #define INT_TYPES_H upstream/emscripten/system/lib/compiler-rt/lib/builtins/int_util.c //===-- int_util.c - Implement internal utilities -------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/lshrdi3.c //===-- lshrdi3.c - Implement __lshrdi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __lshrdi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/lshrti3.c //===-- lshrti3.c - Implement __lshrti3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __lshrti3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/moddi3.c //===-- moddi3.c - Implement __moddi3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __moddi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/modsi3.c //===-- modsi3.c - Implement __modsi3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __modsi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/modti3.c //===-- modti3.c - Implement __modti3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __modti3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/muldc3.c //===-- muldc3.c - Implement __muldc3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __muldc3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/muldf3.c //===-- lib/muldf3.c - Double-precision multiplication ------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements double-precision soft-float multiplication // with the IEEE-754 default rounding (to nearest, ties to even). // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/muldi3.c //===-- muldi3.c - Implement __muldi3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __muldi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/mulodi4.c //===-- mulodi4.c - Implement __mulodi4 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __mulodi4 for the compiler_rt library. // //===----------------------------------------------------------------------===// #define fixint_t di_int #define fixuint_t du_int upstream/emscripten/system/lib/compiler-rt/lib/builtins/mulosi4.c //===-- mulosi4.c - Implement __mulosi4 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __mulosi4 for the compiler_rt library. // //===----------------------------------------------------------------------===// #define fixint_t si_int #define fixuint_t su_int upstream/emscripten/system/lib/compiler-rt/lib/builtins/muloti4.c //===-- muloti4.c - Implement __muloti4 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __muloti4 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/mulsc3.c //===-- mulsc3.c - Implement __mulsc3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __mulsc3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/mulsf3.c //===-- lib/mulsf3.c - Single-precision multiplication ------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements single-precision soft-float multiplication // with the IEEE-754 default rounding (to nearest, ties to even). // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/multc3.c //===-- multc3.c - Implement __multc3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __multc3 for the compiler_rt library. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/multf3.c //===-- lib/multf3.c - Quad-precision multiplication --------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements quad-precision soft-float multiplication // with the IEEE-754 default rounding (to nearest, ties to even). // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/multi3.c //===-- multi3.c - Implement __multi3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __multi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/mulvdi3.c //===-- mulvdi3.c - Implement __mulvdi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __mulvdi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// #define fixint_t di_int #define fixuint_t du_int upstream/emscripten/system/lib/compiler-rt/lib/builtins/mulvsi3.c //===-- mulvsi3.c - Implement __mulvsi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __mulvsi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// #define fixint_t si_int #define fixuint_t su_int upstream/emscripten/system/lib/compiler-rt/lib/builtins/mulvti3.c //===-- mulvti3.c - Implement __mulvti3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __mulvti3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/mulxc3.c //===-- mulxc3.c - Implement __mulxc3 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __mulxc3 for the compiler_rt library. // //===----------------------------------------------------------------------===// #if !_ARCH_PPC upstream/emscripten/system/lib/compiler-rt/lib/builtins/negdf2.c //===-- lib/negdf2.c - double-precision negation ------------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements double-precision soft-float negation. // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/negdi2.c //===-- negdi2.c - Implement __negdi2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __negdi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/negsf2.c //===-- lib/negsf2.c - single-precision negation ------------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements single-precision soft-float negation. // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/negti2.c //===-- negti2.c - Implement __negti2 -------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __negti2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/negvdi2.c //===-- negvdi2.c - Implement __negvdi2 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __negvdi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/negvsi2.c //===-- negvsi2.c - Implement __negvsi2 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __negvsi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/negvti2.c //===-- negvti2.c - Implement __negvti2 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __negvti2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/os_version_check.c //===-- os_version_check.c - OS version checking -------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the function __isOSVersionAtLeast, used by // Objective-C's @available // //===----------------------------------------------------------------------===// #ifdef __APPLE__ upstream/emscripten/system/lib/compiler-rt/lib/builtins/paritydi2.c //===-- paritydi2.c - Implement __paritydi2 -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __paritydi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/paritysi2.c //===-- paritysi2.c - Implement __paritysi2 -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __paritysi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/parityti2.c //===-- parityti2.c - Implement __parityti2 -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __parityti2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/popcountdi2.c //===-- popcountdi2.c - Implement __popcountdi2 ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __popcountdi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/popcountsi2.c //===-- popcountsi2.c - Implement __popcountsi2 ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __popcountsi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/popcountti2.c //===-- popcountti2.c - Implement __popcountti2 //----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __popcountti2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/powidf2.c //===-- powidf2.cpp - Implement __powidf2 ---------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __powidf2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/powisf2.c //===-- powisf2.cpp - Implement __powisf2 ---------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __powisf2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/powitf2.c //===-- powitf2.cpp - Implement __powitf2 ---------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __powitf2 for the compiler_rt library. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/powixf2.c //===-- powixf2.cpp - Implement __powixf2 ---------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __powixf2 for the compiler_rt library. // //===----------------------------------------------------------------------===// #if !_ARCH_PPC upstream/emscripten/system/lib/compiler-rt/lib/builtins/subdf3.c //===-- lib/adddf3.c - Double-precision subtraction ---------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements double-precision soft-float subtraction. // //===----------------------------------------------------------------------===// #define DOUBLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/subsf3.c //===-- lib/subsf3.c - Single-precision subtraction ---------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements single-precision soft-float subtraction. // //===----------------------------------------------------------------------===// #define SINGLE_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/subtf3.c //===-- lib/subtf3.c - Quad-precision subtraction -----------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements quad-precision soft-float subtraction. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/subvdi3.c //===-- subvdi3.c - Implement __subvdi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __subvdi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/subvsi3.c //===-- subvsi3.c - Implement __subvsi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __subvsi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/subvti3.c //===-- subvti3.c - Implement __subvti3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __subvti3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/trampoline_setup.c //===----- trampoline_setup.c - Implement __trampoline_setup -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/truncdfbf2.c //===-- lib/truncdfbf2.c - double -> bfloat conversion ------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SRC_DOUBLE #define DST_BFLOAT upstream/emscripten/system/lib/compiler-rt/lib/builtins/truncdfhf2.c //===-- lib/truncdfhf2.c - double -> half conversion --------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SRC_DOUBLE #define DST_HALF upstream/emscripten/system/lib/compiler-rt/lib/builtins/truncdfsf2.c //===-- lib/truncdfsf2.c - double -> single conversion ------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SRC_DOUBLE #define DST_SINGLE upstream/emscripten/system/lib/compiler-rt/lib/builtins/truncsfbf2.c //===-- lib/truncsfbf2.c - single -> bfloat conversion ------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SRC_SINGLE #define DST_BFLOAT upstream/emscripten/system/lib/compiler-rt/lib/builtins/truncsfhf2.c //===-- lib/truncsfhf2.c - single -> half conversion --------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SRC_SINGLE #define DST_HALF upstream/emscripten/system/lib/compiler-rt/lib/builtins/trunctfbf2.c //===--------- lib/trunctfbf2.c - quad -> bfloat conversion -------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/trunctfdf2.c //===-- lib/truncdfsf2.c - quad -> double conversion --------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/trunctfhf2.c //===-- lib/trunctfhf2.c - quad -> half conversion ----------------*- C -*-===// // // The LLVM Compiler Infrastructure // // This file is dual licensed under the MIT and the University of Illinois Open // Source Licenses. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/trunctfsf2.c //===-- lib/trunctfsf2.c - quad -> single conversion --------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/trunctfxf2.c //===-- lib/trunctfsf2.c - long double -> quad conversion ---------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // Assumption: long double is a IEEE 80 bit floating point type padded to 128 // bits. #define QUAD_PRECISION upstream/emscripten/system/lib/compiler-rt/lib/builtins/truncxfbf2.c //===-- lib/truncxfbf2.c - long double -> bfloat conversion -------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #if defined(CRT_HAS_TF_MODE) && __LDBL_MANT_DIG__ == 64 && defined(__x86_64__) #define SRC_80 #define DST_BFLOAT upstream/emscripten/system/lib/compiler-rt/lib/builtins/truncxfhf2.c //===-- lib/truncsfhf2.c - long double -> half conversion ---------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #define SRC_SINGLE #define DST_HALF upstream/emscripten/system/lib/compiler-rt/lib/builtins/ucmpdi2.c //===-- ucmpdi2.c - Implement __ucmpdi2 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ucmpdi2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/ucmpti2.c //===-- ucmpti2.c - Implement __ucmpti2 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __ucmpti2 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/udivdi3.c //===-- udivdi3.c - Implement __udivdi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __udivdi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/udivmoddi4.c //===-- udivmoddi4.c - Implement __udivmoddi4 -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __udivmoddi4 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/udivmodsi4.c //===-- udivmodsi4.c - Implement __udivmodsi4 -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __udivmodsi4 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/udivmodti4.c //===-- udivmodti4.c - Implement __udivmodti4 -----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __udivmodti4 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/udivsi3.c //===-- udivsi3.c - Implement __udivsi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __udivsi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/udivti3.c //===-- udivti3.c - Implement __udivti3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __udivti3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/umoddi3.c //===-- umoddi3.c - Implement __umoddi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __umoddi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/umodsi3.c //===-- umodsi3.c - Implement __umodsi3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __umodsi3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/umodti3.c //===-- umodti3.c - Implement __umodti3 -----------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements __umodti3 for the compiler_rt library. // //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/builtins/unwind-ehabi-helpers.h //===-- arm-ehabi-helpers.h - Supplementary ARM EHABI declarations --------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===--------------------------------------------------------------------===// #ifndef UNWIND_EHABI_HELPERS_H #define UNWIND_EHABI_HELPERS_H upstream/emscripten/system/lib/compiler-rt/lib/interception/interception.h //===-- interception.h ------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Machinery for providing replacements/wrappers for system functions. //===----------------------------------------------------------------------===// #ifndef INTERCEPTION_H #define INTERCEPTION_H upstream/emscripten/system/lib/compiler-rt/lib/interception/interception_aix.cpp //===-- interception_aix.cpp ------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // AIX-specific interception methods. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/interception/interception_linux.cpp //===-- interception_linux.cpp ----------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Linux-specific interception methods. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/interception/interception_mac.cpp //===-- interception_mac.cpp ------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Mac-specific interception methods. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/interception/interception_type_test.cpp //===-- interception_type_test.cpp ------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Compile-time tests of the internal type definitions. //===----------------------------------------------------------------------===// upstream/emscripten/system/lib/compiler-rt/lib/interception/interception_win.cpp //===-- interception_win.cpp ------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Windows-specific interception methods. // // This file is implementing several hooking techniques to intercept calls // to functions. The hooks are dynamically installed by modifying the assembly // code. // // The hooking techniques are making assumptions on the way the code is // generated and are safe under these assumptions. // // On 64-bit architecture, there is no direct 64-bit jump instruction. To allow // arbitrary branching on the whole memory space, the notion of trampoline // region is used. A trampoline region is a memory space withing 2G boundary // where it is safe to add custom assembly code to build 64-bit jumps. // // Hooking techniques // ================== // // 1) Detour // // The Detour hooking technique is assuming the presence of a header with // padding and an overridable 2-bytes nop instruction (mov edi, edi). The // nop instruction can safely be replaced by a 2-bytes jump without any need // to save the instruction. A jump to the target is encoded in the function // header and the nop instruction is replaced by a short jump to the header. // // head: 5 x nop head: jmp // func: mov edi, edi --> func: jmp short // [...] real: [...] // // This technique is only implemented on 32-bit architecture. // Most of the time, Windows API are hookable with the detour technique. // // 2) Redirect Jump // // The redirect jump is applicable when the first instruction is a direct // jump. The instruction is replaced by jump to the hook. // // func: jmp