llvm/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp

//===- ValueEnumerator.cpp - Number values and types for bitcode writer ---===//
//
// Part of the LLVM Project, under the Apache License v2.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 ValueEnumerator class.
//
//===----------------------------------------------------------------------===//

#include "ValueEnumerator.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/IR/Argument.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/GlobalAlias.h"
#include "llvm/IR/GlobalIFunc.h"
#include "llvm/IR/GlobalObject.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Use.h"
#include "llvm/IR/User.h"
#include "llvm/IR/Value.h"
#include "llvm/IR/ValueSymbolTable.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cstddef>
#include <iterator>
#include <tuple>

usingnamespacellvm;

namespace {

struct OrderMap { … };

} // end anonymous namespace

static void orderValue(const Value *V, OrderMap &OM) { … }

static OrderMap orderModule(const Module &M) { … }

static void predictValueUseListOrderImpl(const Value *V, const Function *F,
                                         unsigned ID, const OrderMap &OM,
                                         UseListOrderStack &Stack) { … }

static void predictValueUseListOrder(const Value *V, const Function *F,
                                     OrderMap &OM, UseListOrderStack &Stack) { … }

static UseListOrderStack predictUseListOrder(const Module &M) { … }

static bool isIntOrIntVectorValue(const std::pair<const Value*, unsigned> &V) { … }

ValueEnumerator::ValueEnumerator(const Module &M,
                                 bool ShouldPreserveUseListOrder)
    : … { … }

unsigned ValueEnumerator::getInstructionID(const Instruction *Inst) const { … }

unsigned ValueEnumerator::getComdatID(const Comdat *C) const { … }

void ValueEnumerator::setInstructionID(const Instruction *I) { … }

unsigned ValueEnumerator::getValueID(const Value *V) const { … }

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
LLVM_DUMP_METHOD void ValueEnumerator::dump() const {
  print(dbgs(), ValueMap, "Default");
  dbgs() << '\n';
  print(dbgs(), MetadataMap, "MetaData");
  dbgs() << '\n';
}
#endif

void ValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map,
                            const char *Name) const { … }

void ValueEnumerator::print(raw_ostream &OS, const MetadataMapType &Map,
                            const char *Name) const { … }

/// OptimizeConstants - Reorder constant pool for denser encoding.
void ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) { … }

/// EnumerateValueSymbolTable - Insert all of the values in the specified symbol
/// table into the values table.
void ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) { … }

/// Insert all of the values referenced by named metadata in the specified
/// module.
void ValueEnumerator::EnumerateNamedMetadata(const Module &M) { … }

void ValueEnumerator::EnumerateNamedMDNode(const NamedMDNode *MD) { … }

unsigned ValueEnumerator::getMetadataFunctionID(const Function *F) const { … }

void ValueEnumerator::EnumerateMetadata(const Function *F, const Metadata *MD) { … }

void ValueEnumerator::EnumerateFunctionLocalMetadata(
    const Function &F, const LocalAsMetadata *Local) { … }

void ValueEnumerator::EnumerateFunctionLocalListMetadata(
    const Function &F, const DIArgList *ArgList) { … }

void ValueEnumerator::dropFunctionFromMetadata(
    MetadataMapType::value_type &FirstMD) { … }

void ValueEnumerator::EnumerateMetadata(unsigned F, const Metadata *MD) { … }

const MDNode *ValueEnumerator::enumerateMetadataImpl(unsigned F, const Metadata *MD) { … }

/// EnumerateFunctionLocalMetadata - Incorporate function-local metadata
/// information reachable from the metadata.
void ValueEnumerator::EnumerateFunctionLocalMetadata(
    unsigned F, const LocalAsMetadata *Local) { … }

/// EnumerateFunctionLocalListMetadata - Incorporate function-local metadata
/// information reachable from the metadata.
void ValueEnumerator::EnumerateFunctionLocalListMetadata(
    unsigned F, const DIArgList *ArgList) { … }

static unsigned getMetadataTypeOrder(const Metadata *MD) { … }

void ValueEnumerator::organizeMetadata() { … }

void ValueEnumerator::incorporateFunctionMetadata(const Function &F) { … }

void ValueEnumerator::EnumerateValue(const Value *V) { … }


void ValueEnumerator::EnumerateType(Type *Ty) { … }

// Enumerate the types for the specified value.  If the value is a constant,
// walk through it, enumerating the types of the constant.
void ValueEnumerator::EnumerateOperandType(const Value *V) { … }

void ValueEnumerator::EnumerateAttributes(AttributeList PAL) { … }

void ValueEnumerator::incorporateFunction(const Function &F) { … }

void ValueEnumerator::purgeFunction() { … }

static void IncorporateFunctionInfoGlobalBBIDs(const Function *F,
                                 DenseMap<const BasicBlock*, unsigned> &IDMap) { … }

/// getGlobalBasicBlockID - This returns the function-specific ID for the
/// specified basic block.  This is relatively expensive information, so it
/// should only be used by rare constructs such as address-of-label.
unsigned ValueEnumerator::getGlobalBasicBlockID(const BasicBlock *BB) const { … }

uint64_t ValueEnumerator::computeBitsRequiredForTypeIndices() const { … }