This is an archive of the discontinued LLVM Phabricator instance.

IR: Move the slot tracker out of AsmWriter into a separate public module.
AbandonedPublic

Authored by arphaman on Jun 17 2015, 1:20 PM.

Download Raw Diff

Details

Reviewers

bob.wilson
bogner
dexonsmith

Summary

This patch moves the SlotTracker class out of AsmWriter.cpp into a separate module that's publicly accessible.

This patch would be useful for MIR Serialization, in particular it would enable the MIR parser to parse metadata machine operands. The metadata machine operands are serialized using the familiar '!' <slot> notation, and the MIR parser has to be able to map from slot numbers to the actual metadata nodes. The SlotTracker class would allow the MIRParser to create this mapping.

Diff Detail

Repository: rL LLVM

Event Timeline

arphaman updated this revision to Diff 27862.Jun 17 2015, 1:20 PM

arphaman retitled this revision from to IR: Move the slot tracker out of AsmWriter into a separate public module..

arphaman updated this object.

arphaman edited the test plan for this revision. (Show Details)

arphaman added reviewers: dexonsmith, bob.wilson, bogner.

arphaman set the repository for this revision to rL LLVM.

arphaman added a subscriber: Unknown Object (MLST).

This patch isn't needed as I should surface the slot mapping from the LLVM IR parsing side rather than the printing side to parse the metadata operands correctly.

Revision Contents

Path

Size

include/

llvm/

IR/

SlotTracker.h

150 lines

lib/

IR/

AsmWriter.cpp

375 lines

CMakeLists.txt

1 line

SlotTracker.cpp

275 lines

Diff 27862

include/llvm/IR/SlotTracker.h

This file was added.

				//===-- llvm/IR/SlotTracker.h - Slot numbers for unnamed values -- C++ --===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//
				//
				// This file contains the declaration of the SlotTracker class. This class
				// enumerates slot numbers for unnamed values, metadata nodes, and attribute
				// sets.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLVM_IR_SLOTTRACKER_H
				#define LLVM_IR_SLOTTRACKER_H

				#include "llvm/ADT/DenseMap.h"
				#include "llvm/IR/Attributes.h"

				namespace llvm {

				class Function;
				class GlobalValue;
				class Instruction;
				class MDNode;
				class Module;
				class Value;

				/// This class provides computation of slot numbers for LLVM Assembly writing.
				///
				class SlotTracker {
				public:
				/// ValueMap - A mapping of Values to slot numbers.
				typedef DenseMap<const Value *, unsigned> ValueMap;

				private:
				/// TheModule - The module for which we are holding slot numbers.
				const Module *TheModule;

				/// TheFunction - The function for which we are holding slot numbers.
				const Function *TheFunction;
				bool FunctionProcessed;
				bool ShouldInitializeAllMetadata;

				/// mMap - The slot map for the module level data.
				ValueMap mMap;
				unsigned mNext;

				/// fMap - The slot map for the function level data.
				ValueMap fMap;
				unsigned fNext;

				/// mdnMap - Map for MDNodes.
				DenseMap<const MDNode *, unsigned> mdnMap;
				unsigned mdnNext;

				/// asMap - The slot map for attribute sets.
				DenseMap<AttributeSet, unsigned> asMap;
				unsigned asNext;

				public:
				/// Construct from a module.
				///
				/// If \c ShouldInitializeAllMetadata, initializes all metadata in all
				/// functions, giving correct numbering for metadata referenced only from
				/// within a function (even if no functions have been initialized).
				explicit SlotTracker(const Module *M,
				bool ShouldInitializeAllMetadata = false);
				/// Construct from a function, starting out in incorp state.
				///
				/// If \c ShouldInitializeAllMetadata, initializes all metadata in all
				/// functions, giving correct numbering for metadata referenced only from
				/// within a function (even if no functions have been initialized).
				explicit SlotTracker(const Function *F,
				bool ShouldInitializeAllMetadata = false);

				/// Return the slot number of the specified value in it's type
				/// plane. If something is not in the SlotTracker, return -1.
				int getLocalSlot(const Value *V);
				int getGlobalSlot(const GlobalValue *V);
				int getMetadataSlot(const MDNode *N);
				int getAttributeGroupSlot(AttributeSet AS);

				/// If you'd like to deal with a function instead of just a module, use
				/// this method to get its data into the SlotTracker.
				void incorporateFunction(const Function *F) {
				TheFunction = F;
				FunctionProcessed = false;
				}

				const Function *getFunction() const { return TheFunction; }

				/// After calling incorporateFunction, use this method to remove the
				/// most recently incorporated function from the SlotTracker. This
				/// will reset the state of the machine back to just the module contents.
				void purgeFunction();

				/// MDNode map iterators.
				typedef DenseMap<const MDNode *, unsigned>::iterator mdn_iterator;
				mdn_iterator mdn_begin() { return mdnMap.begin(); }
				mdn_iterator mdn_end() { return mdnMap.end(); }
				unsigned mdn_size() const { return mdnMap.size(); }
				bool mdn_empty() const { return mdnMap.empty(); }

				/// AttributeSet map iterators.
				typedef DenseMap<AttributeSet, unsigned>::iterator as_iterator;
				as_iterator as_begin() { return asMap.begin(); }
				as_iterator as_end() { return asMap.end(); }
				unsigned as_size() const { return asMap.size(); }
				bool as_empty() const { return asMap.empty(); }

				/// This function does the actual initialization.
				void initialize();

				// Implementation Details
				private:
				/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
				void CreateModuleSlot(const GlobalValue *V);

				/// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
				void CreateMetadataSlot(const MDNode *N);

				/// CreateFunctionSlot - Insert the specified Value* into the slot table.
				void CreateFunctionSlot(const Value *V);

				/// \brief Insert the specified AttributeSet into the slot table.
				void CreateAttributeSetSlot(AttributeSet AS);

				/// Add all of the module level global variables (and their initializers)
				/// and function declarations, but not the contents of those functions.
				void processModule();

				/// Add all of the functions arguments, basic blocks, and instructions.
				void processFunction();

				/// Add all of the metadata from a function.
				void processFunctionMetadata(const Function &F);

				/// Add all of the metadata from an instruction.
				void processInstructionMetadata(const Instruction &I);

				SlotTracker(const SlotTracker &) = delete;
				void operator=(const SlotTracker &) = delete;
				};

				} // end namespace llvm

				#endif

lib/IR/AsmWriter.cpp

Show All 25 Lines
#include "llvm/IR/DebugInfo.h"		#include "llvm/IR/DebugInfo.h"
#include "llvm/IR/DerivedTypes.h"		#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/IRPrintingPasses.h"		#include "llvm/IR/IRPrintingPasses.h"
#include "llvm/IR/InlineAsm.h"		#include "llvm/IR/InlineAsm.h"
#include "llvm/IR/IntrinsicInst.h"		#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h"		#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"		#include "llvm/IR/Module.h"
#include "llvm/IR/Operator.h"		#include "llvm/IR/Operator.h"
		#include "llvm/IR/SlotTracker.h"
#include "llvm/IR/Statepoint.h"		#include "llvm/IR/Statepoint.h"
#include "llvm/IR/TypeFinder.h"		#include "llvm/IR/TypeFinder.h"
#include "llvm/IR/UseListOrder.h"		#include "llvm/IR/UseListOrder.h"
#include "llvm/IR/ValueSymbolTable.h"		#include "llvm/IR/ValueSymbolTable.h"
#include "llvm/Support/Debug.h"		#include "llvm/Support/Debug.h"
#include "llvm/Support/Dwarf.h"		#include "llvm/Support/Dwarf.h"
#include "llvm/Support/ErrorHandling.h"		#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"		#include "llvm/Support/FormattedStream.h"
▲ Show 20 Lines • Show All 493 Lines • ▼ Show 20 Lines	if (STy->getNumElements() == 0) {
}		}

OS << " }";		OS << " }";
}		}
if (STy->isPacked())		if (STy->isPacked())
OS << '>';		OS << '>';
}		}

namespace {
//===----------------------------------------------------------------------===//
// SlotTracker Class: Enumerate slot numbers for unnamed values
//===----------------------------------------------------------------------===//
/// This class provides computation of slot numbers for LLVM Assembly writing.
///
class SlotTracker {
public:
/// ValueMap - A mapping of Values to slot numbers.
typedef DenseMap<const Value*, unsigned> ValueMap;

private:
/// TheModule - The module for which we are holding slot numbers.
const Module* TheModule;

/// TheFunction - The function for which we are holding slot numbers.
const Function* TheFunction;
bool FunctionProcessed;
bool ShouldInitializeAllMetadata;

/// mMap - The slot map for the module level data.
ValueMap mMap;
unsigned mNext;

/// fMap - The slot map for the function level data.
ValueMap fMap;
unsigned fNext;

/// mdnMap - Map for MDNodes.
DenseMap<const MDNode*, unsigned> mdnMap;
unsigned mdnNext;

/// asMap - The slot map for attribute sets.
DenseMap<AttributeSet, unsigned> asMap;
unsigned asNext;
public:
/// Construct from a module.
///
/// If \c ShouldInitializeAllMetadata, initializes all metadata in all
/// functions, giving correct numbering for metadata referenced only from
/// within a function (even if no functions have been initialized).
explicit SlotTracker(const Module *M,
bool ShouldInitializeAllMetadata = false);
/// Construct from a function, starting out in incorp state.
///
/// If \c ShouldInitializeAllMetadata, initializes all metadata in all
/// functions, giving correct numbering for metadata referenced only from
/// within a function (even if no functions have been initialized).
explicit SlotTracker(const Function *F,
bool ShouldInitializeAllMetadata = false);

/// Return the slot number of the specified value in it's type
/// plane. If something is not in the SlotTracker, return -1.
int getLocalSlot(const Value *V);
int getGlobalSlot(const GlobalValue *V);
int getMetadataSlot(const MDNode *N);
int getAttributeGroupSlot(AttributeSet AS);

/// If you'd like to deal with a function instead of just a module, use
/// this method to get its data into the SlotTracker.
void incorporateFunction(const Function *F) {
TheFunction = F;
FunctionProcessed = false;
}

const Function *getFunction() const { return TheFunction; }

/// After calling incorporateFunction, use this method to remove the
/// most recently incorporated function from the SlotTracker. This
/// will reset the state of the machine back to just the module contents.
void purgeFunction();

/// MDNode map iterators.
typedef DenseMap<const MDNode*, unsigned>::iterator mdn_iterator;
mdn_iterator mdn_begin() { return mdnMap.begin(); }
mdn_iterator mdn_end() { return mdnMap.end(); }
unsigned mdn_size() const { return mdnMap.size(); }
bool mdn_empty() const { return mdnMap.empty(); }

/// AttributeSet map iterators.
typedef DenseMap<AttributeSet, unsigned>::iterator as_iterator;
as_iterator as_begin() { return asMap.begin(); }
as_iterator as_end() { return asMap.end(); }
unsigned as_size() const { return asMap.size(); }
bool as_empty() const { return asMap.empty(); }

/// This function does the actual initialization.
inline void initialize();

// Implementation Details
private:
/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
void CreateModuleSlot(const GlobalValue *V);

/// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
void CreateMetadataSlot(const MDNode *N);

/// CreateFunctionSlot - Insert the specified Value* into the slot table.
void CreateFunctionSlot(const Value *V);

/// \brief Insert the specified AttributeSet into the slot table.
void CreateAttributeSetSlot(AttributeSet AS);

/// Add all of the module level global variables (and their initializers)
/// and function declarations, but not the contents of those functions.
void processModule();

/// Add all of the functions arguments, basic blocks, and instructions.
void processFunction();

/// Add all of the metadata from a function.
void processFunctionMetadata(const Function &F);

/// Add all of the metadata from an instruction.
void processInstructionMetadata(const Instruction &I);

SlotTracker(const SlotTracker &) = delete;
void operator=(const SlotTracker &) = delete;
};
} // namespace

static SlotTracker createSlotTracker(const Module M) {		static SlotTracker createSlotTracker(const Module M) {
return new SlotTracker(M);		return new SlotTracker(M);
}		}

static SlotTracker createSlotTracker(const Value V) {		static SlotTracker createSlotTracker(const Value V) {
if (const Argument *FA = dyn_cast<Argument>(V))		if (const Argument *FA = dyn_cast<Argument>(V))
return new SlotTracker(FA->getParent());		return new SlotTracker(FA->getParent());

Show All 11 Lines	if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
return new SlotTracker(GA->getParent());		return new SlotTracker(GA->getParent());

if (const Function *Func = dyn_cast<Function>(V))		if (const Function *Func = dyn_cast<Function>(V))
return new SlotTracker(Func);		return new SlotTracker(Func);

return nullptr;		return nullptr;
}		}

#if 0
#define ST_DEBUG(X) dbgs() << X
#else
#define ST_DEBUG(X)
#endif

// Module level constructor. Causes the contents of the Module (sans functions)
// to be added to the slot table.
SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
: TheModule(M), TheFunction(nullptr), FunctionProcessed(false),
ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
fNext(0), mdnNext(0), asNext(0) {}

// Function level constructor. Causes the contents of the Module and the one
// function provided to be added to the slot table.
SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
: TheModule(F ? F->getParent() : nullptr), TheFunction(F),
FunctionProcessed(false),
ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
fNext(0), mdnNext(0), asNext(0) {}

inline void SlotTracker::initialize() {
if (TheModule) {
processModule();
TheModule = nullptr; ///< Prevent re-processing next time we're called.
}

if (TheFunction && !FunctionProcessed)
processFunction();
}

// Iterate through all the global variables, functions, and global
// variable initializers and create slots for them.
void SlotTracker::processModule() {
ST_DEBUG("begin processModule!\n");

// Add all of the unnamed global variables to the value table.
for (Module::const_global_iterator I = TheModule->global_begin(),
E = TheModule->global_end(); I != E; ++I) {
if (!I->hasName())
CreateModuleSlot(I);
}

// Add metadata used by named metadata.
for (Module::const_named_metadata_iterator
I = TheModule->named_metadata_begin(),
E = TheModule->named_metadata_end(); I != E; ++I) {
const NamedMDNode *NMD = I;
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
CreateMetadataSlot(NMD->getOperand(i));
}

for (Module::const_iterator I = TheModule->begin(), E = TheModule->end();
I != E; ++I) {
if (!I->hasName())
// Add all the unnamed functions to the table.
CreateModuleSlot(I);

if (ShouldInitializeAllMetadata)
processFunctionMetadata(*I);

// Add all the function attributes to the table.
// FIXME: Add attributes of other objects?
AttributeSet FnAttrs = I->getAttributes().getFnAttributes();
if (FnAttrs.hasAttributes(AttributeSet::FunctionIndex))
CreateAttributeSetSlot(FnAttrs);
}

ST_DEBUG("end processModule!\n");
}

// Process the arguments, basic blocks, and instructions of a function.
void SlotTracker::processFunction() {
ST_DEBUG("begin processFunction!\n");
fNext = 0;

// Add all the function arguments with no names.
for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
AE = TheFunction->arg_end(); AI != AE; ++AI)
if (!AI->hasName())
CreateFunctionSlot(AI);

ST_DEBUG("Inserting Instructions:\n");

// Add all of the basic blocks and instructions with no names.
for (auto &BB : *TheFunction) {
if (!BB.hasName())
CreateFunctionSlot(&BB);

processFunctionMetadata(*TheFunction);

for (auto &I : BB) {
if (!I.getType()->isVoidTy() && !I.hasName())
CreateFunctionSlot(&I);

// We allow direct calls to any llvm.foo function here, because the
// target may not be linked into the optimizer.
if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
// Add all the call attributes to the table.
AttributeSet Attrs = CI->getAttributes().getFnAttributes();
if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
CreateAttributeSetSlot(Attrs);
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
// Add all the call attributes to the table.
AttributeSet Attrs = II->getAttributes().getFnAttributes();
if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
CreateAttributeSetSlot(Attrs);
}
}
}

FunctionProcessed = true;

ST_DEBUG("end processFunction!\n");
}

void SlotTracker::processFunctionMetadata(const Function &F) {
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
for (auto &BB : F) {
F.getAllMetadata(MDs);
for (auto &MD : MDs)
CreateMetadataSlot(MD.second);

for (auto &I : BB)
processInstructionMetadata(I);
}
}

void SlotTracker::processInstructionMetadata(const Instruction &I) {
// Process metadata used directly by intrinsics.
if (const CallInst *CI = dyn_cast<CallInst>(&I))
if (Function *F = CI->getCalledFunction())
if (F->isIntrinsic())
for (auto &Op : I.operands())
if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
CreateMetadataSlot(N);

// Process metadata attached to this instruction.
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
I.getAllMetadata(MDs);
for (auto &MD : MDs)
CreateMetadataSlot(MD.second);
}

/// Clean up after incorporating a function. This is the only way to get out of
/// the function incorporation state that affects getSlot/CreateSlot. Function
/// incorporation state is indicated by TheFunction != 0.
void SlotTracker::purgeFunction() {
ST_DEBUG("begin purgeFunction!\n");
fMap.clear(); // Simply discard the function level map
TheFunction = nullptr;
FunctionProcessed = false;
ST_DEBUG("end purgeFunction!\n");
}

/// getGlobalSlot - Get the slot number of a global value.
int SlotTracker::getGlobalSlot(const GlobalValue *V) {
// Check for uninitialized state and do lazy initialization.
initialize();

// Find the value in the module map
ValueMap::iterator MI = mMap.find(V);
return MI == mMap.end() ? -1 : (int)MI->second;
}

/// getMetadataSlot - Get the slot number of a MDNode.
int SlotTracker::getMetadataSlot(const MDNode *N) {
// Check for uninitialized state and do lazy initialization.
initialize();

// Find the MDNode in the module map
mdn_iterator MI = mdnMap.find(N);
return MI == mdnMap.end() ? -1 : (int)MI->second;
}


/// getLocalSlot - Get the slot number for a value that is local to a function.
int SlotTracker::getLocalSlot(const Value *V) {
assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!");

// Check for uninitialized state and do lazy initialization.
initialize();

ValueMap::iterator FI = fMap.find(V);
return FI == fMap.end() ? -1 : (int)FI->second;
}

int SlotTracker::getAttributeGroupSlot(AttributeSet AS) {
// Check for uninitialized state and do lazy initialization.
initialize();

// Find the AttributeSet in the module map.
as_iterator AI = asMap.find(AS);
return AI == asMap.end() ? -1 : (int)AI->second;
}

/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
void SlotTracker::CreateModuleSlot(const GlobalValue *V) {
assert(V && "Can't insert a null Value into SlotTracker!");
assert(!V->getType()->isVoidTy() && "Doesn't need a slot!");
assert(!V->hasName() && "Doesn't need a slot!");

unsigned DestSlot = mNext++;
mMap[V] = DestSlot;

ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
DestSlot << " [");
// G = Global, F = Function, A = Alias, o = other
ST_DEBUG((isa<GlobalVariable>(V) ? 'G' :
(isa<Function>(V) ? 'F' :
(isa<GlobalAlias>(V) ? 'A' : 'o'))) << "]\n");
}

/// CreateSlot - Create a new slot for the specified value if it has no name.
void SlotTracker::CreateFunctionSlot(const Value *V) {
assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!");

unsigned DestSlot = fNext++;
fMap[V] = DestSlot;

// G = Global, F = Function, o = other
ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
DestSlot << " [o]\n");
}

/// CreateModuleSlot - Insert the specified MDNode* into the slot table.
void SlotTracker::CreateMetadataSlot(const MDNode *N) {
assert(N && "Can't insert a null Value into SlotTracker!");

unsigned DestSlot = mdnNext;
if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
return;
++mdnNext;

// Recursively add any MDNodes referenced by operands.
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
CreateMetadataSlot(Op);
}

void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {
assert(AS.hasAttributes(AttributeSet::FunctionIndex) &&
"Doesn't need a slot!");

as_iterator I = asMap.find(AS);
if (I != asMap.end())
return;

unsigned DestSlot = asNext++;
asMap[AS] = DestSlot;
}

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// AsmWriter Implementation		// AsmWriter Implementation
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,		static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
TypePrinting *TypePrinter,		TypePrinting *TypePrinter,
SlotTracker *Machine,		SlotTracker *Machine,
const Module *Context);		const Module *Context);
▲ Show 20 Lines • Show All 992 Lines • Show Last 20 Lines

lib/IR/CMakeLists.txt

Show All 32 Lines	add_llvm_library(LLVMCore
Mangler.cpp		Mangler.cpp
Metadata.cpp		Metadata.cpp
MetadataTracking.cpp		MetadataTracking.cpp
Module.cpp		Module.cpp
Operator.cpp		Operator.cpp
Pass.cpp		Pass.cpp
PassManager.cpp		PassManager.cpp
PassRegistry.cpp		PassRegistry.cpp
		SlotTracker.cpp
Statepoint.cpp		Statepoint.cpp
Type.cpp		Type.cpp
TypeFinder.cpp		TypeFinder.cpp
Use.cpp		Use.cpp
User.cpp		User.cpp
Value.cpp		Value.cpp
ValueSymbolTable.cpp		ValueSymbolTable.cpp
ValueTypes.cpp		ValueTypes.cpp
Verifier.cpp		Verifier.cpp

ADDITIONAL_HEADER_DIRS		ADDITIONAL_HEADER_DIRS
${LLVM_MAIN_INCLUDE_DIR}/llvm/IR		${LLVM_MAIN_INCLUDE_DIR}/llvm/IR
)		)

add_dependencies(LLVMCore intrinsics_gen)		add_dependencies(LLVMCore intrinsics_gen)

lib/IR/SlotTracker.cpp

This file was added.

				//===-- SlotTracker.cpp - Implements the SlotTracker class ----------------===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//
				//
				// This file implements the SlotTracker class. This class enumerates slot
				// numbers for unnamed values, metadata nodes, and attribute sets.
				//
				//===----------------------------------------------------------------------===//

				#include "llvm/IR/SlotTracker.h"
				#include "llvm/IR/BasicBlock.h"
				#include "llvm/IR/Function.h"
				#include "llvm/IR/Instructions.h"
				#include "llvm/IR/Module.h"
				#include "llvm/IR/Value.h"

				using namespace llvm;

				#if 0
				#define ST_DEBUG(X) dbgs() << X
				#else
				#define ST_DEBUG(X)
				#endif

				// Module level constructor. Causes the contents of the Module (sans functions)
				// to be added to the slot table.
				SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
				: TheModule(M), TheFunction(nullptr), FunctionProcessed(false),
				ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
				fNext(0), mdnNext(0), asNext(0) {}

				// Function level constructor. Causes the contents of the Module and the one
				// function provided to be added to the slot table.
				SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
				: TheModule(F ? F->getParent() : nullptr), TheFunction(F),
				FunctionProcessed(false),
				ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
				fNext(0), mdnNext(0), asNext(0) {}

				void SlotTracker::initialize() {
				if (TheModule) {
				processModule();
				TheModule = nullptr; ///< Prevent re-processing next time we're called.
				}

				if (TheFunction && !FunctionProcessed)
				processFunction();
				}

				// Iterate through all the global variables, functions, and global
				// variable initializers and create slots for them.
				void SlotTracker::processModule() {
				ST_DEBUG("begin processModule!\n");

				// Add all of the unnamed global variables to the value table.
				for (Module::const_global_iterator I = TheModule->global_begin(),
				E = TheModule->global_end(); I != E; ++I) {
				if (!I->hasName())
				CreateModuleSlot(I);
				}

				// Add metadata used by named metadata.
				for (Module::const_named_metadata_iterator
				I = TheModule->named_metadata_begin(),
				E = TheModule->named_metadata_end(); I != E; ++I) {
				const NamedMDNode *NMD = I;
				for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
				CreateMetadataSlot(NMD->getOperand(i));
				}

				for (Module::const_iterator I = TheModule->begin(), E = TheModule->end();
				I != E; ++I) {
				if (!I->hasName())
				// Add all the unnamed functions to the table.
				CreateModuleSlot(I);

				if (ShouldInitializeAllMetadata)
				processFunctionMetadata(*I);

				// Add all the function attributes to the table.
				// FIXME: Add attributes of other objects?
				AttributeSet FnAttrs = I->getAttributes().getFnAttributes();
				if (FnAttrs.hasAttributes(AttributeSet::FunctionIndex))
				CreateAttributeSetSlot(FnAttrs);
				}

				ST_DEBUG("end processModule!\n");
				}

				// Process the arguments, basic blocks, and instructions of a function.
				void SlotTracker::processFunction() {
				ST_DEBUG("begin processFunction!\n");
				fNext = 0;

				// Add all the function arguments with no names.
				for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
				AE = TheFunction->arg_end(); AI != AE; ++AI)
				if (!AI->hasName())
				CreateFunctionSlot(AI);

				ST_DEBUG("Inserting Instructions:\n");

				// Add all of the basic blocks and instructions with no names.
				for (auto &BB : *TheFunction) {
				if (!BB.hasName())
				CreateFunctionSlot(&BB);

				processFunctionMetadata(*TheFunction);

				for (auto &I : BB) {
				if (!I.getType()->isVoidTy() && !I.hasName())
				CreateFunctionSlot(&I);

				// We allow direct calls to any llvm.foo function here, because the
				// target may not be linked into the optimizer.
				if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
				// Add all the call attributes to the table.
				AttributeSet Attrs = CI->getAttributes().getFnAttributes();
				if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
				CreateAttributeSetSlot(Attrs);
				} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
				// Add all the call attributes to the table.
				AttributeSet Attrs = II->getAttributes().getFnAttributes();
				if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
				CreateAttributeSetSlot(Attrs);
				}
				}
				}

				FunctionProcessed = true;

				ST_DEBUG("end processFunction!\n");
				}

				void SlotTracker::processFunctionMetadata(const Function &F) {
				SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
				for (auto &BB : F) {
				F.getAllMetadata(MDs);
				for (auto &MD : MDs)
				CreateMetadataSlot(MD.second);

				for (auto &I : BB)
				processInstructionMetadata(I);
				}
				}

				void SlotTracker::processInstructionMetadata(const Instruction &I) {
				// Process metadata used directly by intrinsics.
				if (const CallInst *CI = dyn_cast<CallInst>(&I))
				if (Function *F = CI->getCalledFunction())
				if (F->isIntrinsic())
				for (auto &Op : I.operands())
				if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
				if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
				CreateMetadataSlot(N);

				// Process metadata attached to this instruction.
				SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
				I.getAllMetadata(MDs);
				for (auto &MD : MDs)
				CreateMetadataSlot(MD.second);
				}

				/// Clean up after incorporating a function. This is the only way to get out of
				/// the function incorporation state that affects getSlot/CreateSlot. Function
				/// incorporation state is indicated by TheFunction != 0.
				void SlotTracker::purgeFunction() {
				ST_DEBUG("begin purgeFunction!\n");
				fMap.clear(); // Simply discard the function level map
				TheFunction = nullptr;
				FunctionProcessed = false;
				ST_DEBUG("end purgeFunction!\n");
				}

				/// getGlobalSlot - Get the slot number of a global value.
				int SlotTracker::getGlobalSlot(const GlobalValue *V) {
				// Check for uninitialized state and do lazy initialization.
				initialize();

				// Find the value in the module map
				ValueMap::iterator MI = mMap.find(V);
				return MI == mMap.end() ? -1 : (int)MI->second;
				}

				/// getMetadataSlot - Get the slot number of a MDNode.
				int SlotTracker::getMetadataSlot(const MDNode *N) {
				// Check for uninitialized state and do lazy initialization.
				initialize();

				// Find the MDNode in the module map
				mdn_iterator MI = mdnMap.find(N);
				return MI == mdnMap.end() ? -1 : (int)MI->second;
				}


				/// getLocalSlot - Get the slot number for a value that is local to a function.
				int SlotTracker::getLocalSlot(const Value *V) {
				assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!");

				// Check for uninitialized state and do lazy initialization.
				initialize();

				ValueMap::iterator FI = fMap.find(V);
				return FI == fMap.end() ? -1 : (int)FI->second;
				}

				int SlotTracker::getAttributeGroupSlot(AttributeSet AS) {
				// Check for uninitialized state and do lazy initialization.
				initialize();

				// Find the AttributeSet in the module map.
				as_iterator AI = asMap.find(AS);
				return AI == asMap.end() ? -1 : (int)AI->second;
				}

				/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
				void SlotTracker::CreateModuleSlot(const GlobalValue *V) {
				assert(V && "Can't insert a null Value into SlotTracker!");
				assert(!V->getType()->isVoidTy() && "Doesn't need a slot!");
				assert(!V->hasName() && "Doesn't need a slot!");

				unsigned DestSlot = mNext++;
				mMap[V] = DestSlot;

				ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
				DestSlot << " [");
				// G = Global, F = Function, A = Alias, o = other
				ST_DEBUG((isa<GlobalVariable>(V) ? 'G' :
				(isa<Function>(V) ? 'F' :
				(isa<GlobalAlias>(V) ? 'A' : 'o'))) << "]\n");
				}

				/// CreateSlot - Create a new slot for the specified value if it has no name.
				void SlotTracker::CreateFunctionSlot(const Value *V) {
				assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!");

				unsigned DestSlot = fNext++;
				fMap[V] = DestSlot;

				// G = Global, F = Function, o = other
				ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
				DestSlot << " [o]\n");
				}

				/// CreateModuleSlot - Insert the specified MDNode* into the slot table.
				void SlotTracker::CreateMetadataSlot(const MDNode *N) {
				assert(N && "Can't insert a null Value into SlotTracker!");

				unsigned DestSlot = mdnNext;
				if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
				return;
				++mdnNext;

				// Recursively add any MDNodes referenced by operands.
				for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
				if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
				CreateMetadataSlot(Op);
				}

				void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {
				assert(AS.hasAttributes(AttributeSet::FunctionIndex) &&
				"Doesn't need a slot!");

				as_iterator I = asMap.find(AS);
				if (I != asMap.end())
				return;

				unsigned DestSlot = asNext++;
				asMap[AS] = DestSlot;
				}