enum TypeID {
    // PrimitiveTypes
    HalfTyID = 0,  ///< 16-bit floating point type
    BFloatTyID,    ///< 16-bit floating point type (7-bit significand)
    FloatTyID,     ///< 32-bit floating point type
    DoubleTyID,    ///< 64-bit floating point type
    X86_FP80TyID,  ///< 80-bit floating point type (X87)
    FP128TyID,     ///< 128-bit floating point type (112-bit significand)
    PPC_FP128TyID, ///< 128-bit floating point type (two 64-bits, PowerPC)
    VoidTyID,      ///< type with no size
    LabelTyID,     ///< Labels
    MetadataTyID,  ///< Metadata
    X86_MMXTyID,   ///< MMX vectors (64 bits, X86 specific)
    X86_AMXTyID,   ///< AMX vectors (8192 bits, X86 specific)
    TokenTyID,     ///< Tokens

    // Derived types... see DerivedTypes.h file.
    IntegerTyID,       ///< Arbitrary bit width integers
    FunctionTyID,      ///< Functions
    PointerTyID,       ///< Pointers
    StructTyID,        ///< Structures
    ArrayTyID,         ///< Arrays
    FixedVectorTyID,   ///< Fixed width SIMD vector type
    ScalableVectorTyID ///< Scalable SIMD vector type
};

LLVMContextImpl *const pImpl;

LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
    : DiagHandler(std::make_unique<DiagnosticHandler>()),
      VoidTy(C, Type::VoidTyID), LabelTy(C, Type::LabelTyID),
      HalfTy(C, Type::HalfTyID), BFloatTy(C, Type::BFloatTyID),
      FloatTy(C, Type::FloatTyID), DoubleTy(C, Type::DoubleTyID),
      MetadataTy(C, Type::MetadataTyID), TokenTy(C, Type::TokenTyID),
      X86_FP80Ty(C, Type::X86_FP80TyID), FP128Ty(C, Type::FP128TyID),
      PPC_FP128Ty(C, Type::PPC_FP128TyID), X86_MMXTy(C, Type::X86_MMXTyID),
      X86_AMXTy(C, Type::X86_AMXTyID), Int1Ty(C, 1), Int8Ty(C, 8),
      Int16Ty(C, 16), Int32Ty(C, 32), Int64Ty(C, 64), Int128Ty(C, 128) {
  if (OpaquePointersCL.getNumOccurrences()) {
    OpaquePointers = OpaquePointersCL;
  }
}

llvm::Type *type = llvm::Type::getVoidTy(TheContext);

define dso_local void @foo() #0 {
  ret void
}

define dso_local i32 @max(i32 noundef %0, i32 noundef %1) #0 {
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  store i32 %0, i32* %3, align 4
  store i32 %1, i32* %4, align 4
  %5 = load i32, i32* %3, align 4
  %6 = load i32, i32* %4, align 4
  %7 = icmp sgt i32 %5, %6
  br i1 %7, label %8, label %10

8:                                                ; preds = %2
  %9 = load i32, i32* %3, align 4
  br label %12

10:                                               ; preds = %2
  %11 = load i32, i32* %4, align 4
  br label %12

12:                                               ; preds = %10, %8
  %13 = phi i32 [ %9, %8 ], [ %11, %10 ]
  ret i32 %13
}

!llvm.module.flags = !{!0, !1, !2, !3, !4}
!llvm.ident = !{!5}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 7, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 1}
!4 = !{i32 7, !"frame-pointer", i32 2}
!5 = !{!"clang version 14.0.6"}

llvm::Type *type = llvm::Type::getInt32Ty(TheContext);

  TypeID   ID : 8;            // The current base type of this type.
  unsigned SubclassData : 24; // Space for subclasses to store data.
                              // Note that this should be synchronized with
                              // MAX_INT_BITS value in IntegerType class.

DenseMap<unsigned, IntegerType *> IntegerTypes;

llvm::Type *type = llvm::Type::getInt32PtrTy(TheContext, 0);

DenseMap<Type *, PointerType *> PointerTypes; // Pointers in AddrSpace = 0
DenseMap<std::pair<Type *, unsigned>, PointerType *> ASPointerTypes;

load i64* %p

load i64, ptr %p

llvm::Type *type = llvm::ArrayType::get(llvm::Type::getInt32Ty(TheContext), 40);

DenseMap<std::pair<Type *, uint64_t>, ArrayType *> ArrayTypes;

llvm::Type *type = llvm::VectorType::get(llvm::Type::getInt32Ty(TheContext), 4, true);

DenseMap<std::pair<Type *, ElementCount>, VectorType *> VectorTypes;

static VectorType *get(Type *ElementType, unsigned NumElements, bool Scalable) {
    return VectorType::get(ElementType, ElementCount::get(NumElements, Scalable));
}

static LeafTy get(ScalarTy MinVal, bool Scalable) {
    return static_cast<LeafTy>(LinearPolySize(MinVal, Scalable ? 1 : 0));
}

/// UnivariateLinearPolyBase is a base class for ElementCount and TypeSize.
/// Like LinearPolyBase it tries to represent a linear polynomial
/// where only one dimension can be set at any time, e.g.
///   0 * scale0 + 0 * scale1 + ... + cJ * scaleJ + ... + 0 * scaleK
/// The dimension that is set is the univariate dimension.

define dso_local noundef <8 x float> @_Z13_mm256_abs_psDv8_f(<8 x float> noundef %0) local_unnamed_addr #0 {
  %2 = fcmp olt <8 x float> %0, zeroinitializer
  %3 = fsub <8 x float> zeroinitializer, %0
  %4 = select <8 x i1> %2, <8 x float> %3, <8 x float> %0
  ret <8 x float> %4
}

using StructTypeSet = DenseSet<StructType *, AnonStructTypeKeyInfo>;
StructTypeSet AnonStructTypes;

ArrayRef<Type *> ETypes;
bool isPacked;

llvm::Type *i32 = llvm::Type::getInt32Ty(TheContext);
std::array<llvm::Type *, 3> elems = {i32, i32, i32};
llvm::Type *type = llvm::StructType::get(TheContext, elems, false);

StringMap<StructType *> NamedStructTypes;
unsigned NamedStructTypesUniqueID = 0;

llvm::Type *i32 = llvm::Type::getInt32Ty(TheContext);
std::array<llvm::Type *, 3> elems = {i32, i32, i32};
llvm::Type *type = llvm::StructType::create(TheContext, elems, "A", false);

enum {
    /// This is the contents of the SubClassData field.
    SCDB_HasBody = 1,
    SCDB_Packed = 2,
    SCDB_IsLiteral = 4,
    SCDB_IsSized = 8
};

struct A;
struct B {
  A* a;
};

%struct.B = type { %struct.A* }
%struct.A = type opaque

struct __attribute__((packed)) A {
    int i;
    short s;
    char c;
};

%struct.A = type <{ i32, i16, i8 }>

struct A {
  struct {
    int i;
    int j;
    int k;
  } x;
  struct {
    int i;
    int j;
    int k;
  } y;
};

%struct.A = type { %struct.anon, %struct.anon.0 }
%struct.anon = type { i32, i32, i32 }
%struct.anon.0 = type { i32, i32, i32 }

using FunctionTypeSet = DenseSet<FunctionType *, FunctionTypeKeyInfo>;
FunctionTypeSet FunctionTypes;

const Type *ReturnType;
ArrayRef<Type *> Params;
bool isVarArg;

llvm::Type *i32 = llvm::Type::getInt32Ty(TheContext);
std::array<llvm::Type *, 1> args = {i32};
llvm::Type *type = llvm::FunctionType::get(i32, args, false);

#include <stdio.h>
int main() { printf("hello world\n"); }

@.str = private unnamed_addr constant [13 x i8] c"hello world\0A\00", align 1

define dso_local i32 @main() #0 {
  %1 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0))
  ret i32 0
}

class Value {
  Type *VTy;
  Use *UseList;
  ...

llvm::Value *value = ...
for (auto it = value->use_begin(); it != value->use_end(); ++it) {
    llvm::Value *user = it->get();
    ...
}

/// Change all uses of this to point to a new Value.
///
/// Go through the uses list for this definition and make each use point to
/// "V" instead of "this".  After this completes, 'this's use list is
/// guaranteed to be empty.
void replaceAllUsesWith(Value *V);

DenseMap<const Value *, ValueName *> ValueNames;

using ValueName = StringMapEntry<Value *>;

llvm::Instruction *ins = ...
for (auto it = ins->op_begin(); it != ins->op_end(); ++it) {
    llvm::Value *value = it->get();
    ...
}

using IntMapTy = DenseMap<APInt, std::unique_ptr<ConstantInt>, DenseMapAPIntKeyInfo>;
IntMapTy IntConstants;

llvm::Value *value = llvm::ConstantInt::get(TheContext, llvm::APInt(32, 100, false /* isSigned */));

union {
    uint64_t VAL;   ///< Used to store the <= 64 bits integer value.
    uint64_t *pVal; ///< Used to store the >64 bits integer value.
} U;

ConstantInt *TheTrueVal = nullptr;
ConstantInt *TheFalseVal = nullptr;

llvm::Value *value = llvm::ConstantInt::getTrue(TheContext);

using FPMapTy = DenseMap<APFloat, std::unique_ptr<ConstantFP>, DenseMapAPFloatKeyInfo>;
FPMapTy FPConstants;

llvm::Value *value = llvm::ConstantFP::get(TheContext, llvm::APFloat(static_cast<float>(1.1)));

float foo() { return 1.1; }

define dso_local noundef float @_Z3foov() #0 {
  ret float 0x3FF19999A0000000
}

const int arr[42] = {0};

@_ZL3arr = internal constant [42 x i32] zeroinitializer, align 16

llvm::Value *value = llvm::ConstantAggregateZero::get(llvm::Type::getInt32Ty(TheContext));

DenseMap<Type *, std::unique_ptr<ConstantAggregateZero>> CAZConstants;

void *foo() { return nullptr; }

define dso_local noundef i8* @_Z3foov() #0 {
  ret i8* null
}

llvm::Value *value = llvm::ConstantPointerNull::get(llvm::Type::getInt8PtrTy(TheContext));

DenseMap<PointerType *, std::unique_ptr<ConstantPointerNull>> CPNConstants;

const int arr[] = { 0, 1, 2 };

@_ZL3arr = internal constant [3 x i32] [i32 0, i32 1, i32 2], align 4

std::array<int, 3> elems = {0, 1, 2};
llvm::Value *value = llvm::ConstantDataArray::get(TheContext, elems);

#include <immintrin.h>
__m256 foo() { return _mm256_set1_ps(1); }

define dso_local noundef <8 x float> @_Z3foov() local_unnamed_addr #0 {
  ret <8 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>
}

std::array<float, 8> elems = {1, 1, 1, 1, 1, 1, 1, 1};
llvm::Value *value = llvm::ConstantDataVector::get(TheContext, elems);

StringMap<std::unique_ptr<ConstantDataSequential>> CDSConstants;

Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<float> Elts) {
  auto *Ty = FixedVectorType::get(Type::getFloatTy(Context), Elts.size());
  const char *Data = reinterpret_cast<const char *>(Elts.data());
  return getImpl(StringRef(Data, Elts.size() * 4), Ty);
}

Constant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) {
  // If the elements are all zero or there are no elements, return a CAZ, which
  // is more dense and canonical.
  if (isAllZeros(Elements))
    return ConstantAggregateZero::get(Ty);

struct A {
  int i;
  int j;
};
const A a = {1, 1};

%struct.A = type { i32, i32 }
@_ZL1a = internal constant %struct.A { i32 1, i32 1 }, align 4

llvm::Type *i32 = llvm::Type::getInt32Ty(TheContext);
llvm::StructType *type = llvm::StructType::create(TheContext, {i32, i32}, "A", false);
llvm::Constant *one = llvm::ConstantInt::get(TheContext, llvm::APInt(32, 1, false /* isSigned */));
std::array<llvm::Constant *, 2> consts = {one, one};
llvm::Value *value = llvm::ConstantStruct::get(type, consts);

using StructConstantsTy = ConstantUniqueMap<ConstantStruct>;
StructConstantsTy StructConstants;

struct A {
  int i;
  int j;
};
const A a[] = {{1, 1},{1, 1}};

%struct.A = type { i32, i32 }
@_ZL1a = internal constant [2 x %struct.A] [%struct.A { i32 1, i32 1 }, %struct.A { i32 1, i32 1 }], align 16

using ArrayConstantsTy = ConstantUniqueMap<ConstantArray>;
ArrayConstantsTy ArrayConstants;

template <class ConstantClass> class ConstantUniqueMap {
public:
  using ValType = typename ConstantInfo<ConstantClass>::ValType;
  using TypeClass = typename ConstantInfo<ConstantClass>::TypeClass;
  using LookupKey = std::pair<TypeClass *, ValType>;

template <> struct ConstantInfo<ConstantArray> {
  using ValType = ConstantAggrKeyType<ConstantArray>;
  using TypeClass = ArrayType;
};

template <class ConstantClass> struct ConstantAggrKeyType {
  ArrayRef<Constant *> Operands;

{ArrayType *, ArrayRef<Constant *>}

int a{1};

@a = dso_local global i32 1, align 4

static int a{1};

@_ZL1a = internal global i32 1, align 4

13: 0000000000004010     4 OBJECT  LOCAL  DEFAULT   22 _ZL1a

auto *value = new llvm::GlobalVariable(llvm::Type::getInt32Ty(TheContext), false /* isConstant */, llvm::GlobalValue::LinkageTypes::InternalLinkage);
value->setInitializer(llvm::ConstantInt::get(TheContext, llvm::APInt(32, 1, false /* isSigned */)));

@<GlobalVarName> = [Linkage] [PreemptionSpecifier] [Visibility]
                   [DLLStorageClass] [ThreadLocal]
                   [(unnamed_addr|local_unnamed_addr)] [AddrSpace]
                   [ExternallyInitialized]
                   <global | constant> <Type> [<InitializerConstant>]
                   [, section "name"] [, partition "name"]
                   [, comdat [($name)]] [, align <Alignment>]
                   [, no_sanitize_address] [, no_sanitize_hwaddress]
                   [, sanitize_address_dyninit] [, sanitize_memtag]
                   (, !name !N)*

GlobalListType GlobalList;      ///< The Global Variables in the module

/// The type for the list of global variables.
using GlobalListType = SymbolTableList<GlobalVariable>;

for (auto it = TheModule->global_begin(); it != TheModule->global_end(); ++it) {
    llvm::GlobalVariable &value = *it;
    ...
}

class GlobalVariable : public GlobalObject, public ilist_node<GlobalVariable>

int foo(int) { return {}; }

; Function Attrs: mustprogress nofree norecurse nosync nounwind readnone sspstrong uwtable willreturn
define dso_local noundef i32 @_Z3fooi(i32 noundef %0) local_unnamed_addr #0 {
  ret i32 0
}

define [linkage] [PreemptionSpecifier] [visibility] [DLLStorageClass]
       [cconv] [ret attrs]
       <ResultType> @<FunctionName> ([argument list])
       [(unnamed_addr|local_unnamed_addr)] [AddrSpace] [fn Attrs]
       [section "name"] [partition "name"] [comdat [($name)]] [align N]
       [gc] [prefix Constant] [prologue Constant] [personality Constant]
       (!name !N)* { ... }

llvm::Type *i32 = llvm::Type::getInt32Ty(TheContext);
std::array<llvm::Type *, 1> args = {i32};
llvm::FunctionType *type = llvm::FunctionType::get(i32, args, false);
llvm::Value *func = llvm::Function::Create(type, llvm::GlobalValue::LinkageTypes::ExternalLinkage, 0 /* AddrSpace */);

extern int printf (const char *__restrict __format, ...);

declare noundef i32 @_Z6printfPKcz(i8* noundef, ...) #1

declare [linkage] [visibility] [DLLStorageClass]
        [cconv] [ret attrs]
        <ResultType> @<FunctionName> ([argument list])
        [(unnamed_addr|local_unnamed_addr)] [align N] [gc]
        [prefix Constant] [prologue Constant]

FunctionListType FunctionList;  ///< The Functions in the module

using BasicBlockListType = SymbolTableList<BasicBlock>;
...
// Important things that make up a function!
BasicBlockListType BasicBlocks;             ///< The basic blocks
mutable Argument *Arguments = nullptr;      ///< The formal arguments
size_t NumArgs;
std::unique_ptr<ValueSymbolTable> SymTab;   ///< Symbol table of args/instructions
AttributeList AttributeSets;                ///< Parameter attributes

Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags, Type *OnlyIfReducedTy)

if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
    return FC;

ConstantUniqueMap<ConstantExpr> ExprConstants;