llvm/llvm/include/llvm/Bitcode/LLVMBitCodes.h

//===- LLVMBitCodes.h - Enum values for the LLVM bitcode format -*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License 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 defines Bitcode enum values for LLVM IR bitcode files.
//
// The enum values defined in this file should be considered permanent.  If
// new features are added, they should have values added at the end of the
// respective lists.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_BITCODE_LLVMBITCODES_H
#define LLVM_BITCODE_LLVMBITCODES_H

// This is the only file included, and it, in turn, is a leaf header.
// This allows external tools to dump the AST of this file and analyze it for
// changes without needing to fully or partially build LLVM itself.
#include "llvm/Bitstream/BitCodeEnums.h"

namespace llvm {
namespace bitc {
// The only top-level block types are MODULE, IDENTIFICATION, STRTAB and SYMTAB.
enum BlockIDs { … };

/// Identification block contains a string that describes the producer details,
/// and an epoch that defines the auto-upgrade capability.
enum IdentificationCodes { … };

/// The epoch that defines the auto-upgrade compatibility for the bitcode.
///
/// LLVM guarantees in a major release that a minor release can read bitcode
/// generated by previous minor releases. We translate this by making the reader
/// accepting only bitcode with the same epoch, except for the X.0 release which
/// also accepts N-1.
enum { … };

/// MODULE blocks have a number of optional fields and subblocks.
enum ModuleCodes { … };

/// PARAMATTR blocks have code for defining a parameter attribute set.
enum AttributeCodes { … };

/// TYPE blocks have codes for each type primitive they use.
enum TypeCodes { … };

enum OperandBundleTagCode { … };

enum SyncScopeNameCode { … };

// Value symbol table codes.
enum ValueSymtabCodes { … };

// The module path symbol table only has one code (MST_CODE_ENTRY).
enum ModulePathSymtabCodes { … };

// The summary section uses different codes in the per-module
// and combined index cases.
enum GlobalValueSummarySymtabCodes { … };

enum MetadataCodes { … };

// The constants block (CONSTANTS_BLOCK_ID) describes emission for each
// constant and maintains an implicit current type value.
enum ConstantsCodes { … };

/// CastOpcodes - These are values used in the bitcode files to encode which
/// cast a CST_CODE_CE_CAST or a XXX refers to.  The values of these enums
/// have no fixed relation to the LLVM IR enum values.  Changing these will
/// break compatibility with old files.
enum CastOpcodes { … };

/// UnaryOpcodes - These are values used in the bitcode files to encode which
/// unop a CST_CODE_CE_UNOP or a XXX refers to.  The values of these enums
/// have no fixed relation to the LLVM IR enum values.  Changing these will
/// break compatibility with old files.
enum UnaryOpcodes { … };

/// BinaryOpcodes - These are values used in the bitcode files to encode which
/// binop a CST_CODE_CE_BINOP or a XXX refers to.  The values of these enums
/// have no fixed relation to the LLVM IR enum values.  Changing these will
/// break compatibility with old files.
enum BinaryOpcodes { … };

/// These are values used in the bitcode files to encode AtomicRMW operations.
/// The values of these enums have no fixed relation to the LLVM IR enum
/// values.  Changing these will break compatibility with old files.
enum RMWOperations { … };

/// OverflowingBinaryOperatorOptionalFlags - Flags for serializing
/// OverflowingBinaryOperator's SubclassOptionalData contents.
enum OverflowingBinaryOperatorOptionalFlags { … };

/// TruncInstOptionalFlags - Flags for serializing
/// TruncInstOptionalFlags's SubclassOptionalData contents.
enum TruncInstOptionalFlags { … };

/// FastMath Flags
/// This is a fixed layout derived from the bitcode emitted by LLVM 5.0
/// intended to decouple the in-memory representation from the serialization.
enum FastMathMap { … };

/// Flags for serializing PossiblyNonNegInst's SubclassOptionalData contents.
enum PossiblyNonNegInstOptionalFlags { … };

/// PossiblyExactOperatorOptionalFlags - Flags for serializing
/// PossiblyExactOperator's SubclassOptionalData contents.
enum PossiblyExactOperatorOptionalFlags { … };

/// PossiblyDisjointInstOptionalFlags - Flags for serializing
/// PossiblyDisjointInst's SubclassOptionalData contents.
enum PossiblyDisjointInstOptionalFlags { … };

/// GetElementPtrOptionalFlags - Flags for serializing
/// GEPOperator's SubclassOptionalData contents.
enum GetElementPtrOptionalFlags { … };

/// Encoded AtomicOrdering values.
enum AtomicOrderingCodes { … };

/// Markers and flags for call instruction.
enum CallMarkersFlags { … };

// The function body block (FUNCTION_BLOCK_ID) describes function bodies.  It
// can contain a constant block (CONSTANTS_BLOCK_ID).
enum FunctionCodes { … };

enum UseListCodes { … };

enum AttributeKindCodes { … };

enum ComdatSelectionKindCodes { … };

enum StrtabCodes { … };

enum SymtabCodes { … };

} // End bitc namespace
} // End llvm namespace

#endif