unittests/IR/ModuleTest.cpp - llvm-project/llvm - Git at Google

 //===- unittests/IR/ModuleTest.cpp - Module unit tests --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "llvm/IR/Module.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SourceMgr.h"
 #include "gtest/gtest.h"

 #include <random>

 using namespace llvm;

 namespace {

 bool sortByName(const GlobalVariable &L, const GlobalVariable &R) {
   return L.getName() < R.getName();
 }

 bool sortByNameReverse(const GlobalVariable &L, const GlobalVariable &R) {
   return sortByName(R, L);
 }

 TEST(ModuleTest, sortGlobalsByName) {
   LLVMContext Context;
   for (auto compare : {&sortByName, &sortByNameReverse}) {
     Module M("M", Context);
     Type *T = Type::getInt8Ty(Context);
     GlobalValue::LinkageTypes L = GlobalValue::ExternalLinkage;
     (void)new GlobalVariable(M, T, false, L, nullptr, "A");
     (void)new GlobalVariable(M, T, false, L, nullptr, "F");
     (void)new GlobalVariable(M, T, false, L, nullptr, "G");
     (void)new GlobalVariable(M, T, false, L, nullptr, "E");
     (void)new GlobalVariable(M, T, false, L, nullptr, "B");
     (void)new GlobalVariable(M, T, false, L, nullptr, "H");
     (void)new GlobalVariable(M, T, false, L, nullptr, "C");
     (void)new GlobalVariable(M, T, false, L, nullptr, "D");

     // Sort the globals by name.
     EXPECT_FALSE(std::is_sorted(M.global_begin(), M.global_end(), compare));
   }
 }

 TEST(ModuleTest, randomNumberGenerator) {
   LLVMContext Context;
   static char ID;
   struct DummyPass : ModulePass {
     DummyPass() : ModulePass(ID) {}
     bool runOnModule(Module &) override { return true; }
   } DP;

   Module M("R", Context);

   std::uniform_int_distribution<int> dist;
   const size_t NBCheck = 10;

   std::array<int, NBCheck> RandomStreams[2];
   for (auto &RandomStream : RandomStreams) {
     std::unique_ptr<RandomNumberGenerator> RNG = M.createRNG(DP.getPassName());
     std::generate(RandomStream.begin(), RandomStream.end(),
                   [&]() { return dist(*RNG); });
   }

   EXPECT_TRUE(std::equal(RandomStreams[0].begin(), RandomStreams[0].end(),
                          RandomStreams[1].begin()));
 }

 TEST(ModuleTest, setModuleFlag) {
   LLVMContext Context;
   Module M("M", Context);
   StringRef Key = "Key";
   Metadata *Val1 = MDString::get(Context, "Val1");
   Metadata *Val2 = MDString::get(Context, "Val2");
   EXPECT_EQ(nullptr, M.getModuleFlag(Key));
   M.setModuleFlag(Module::ModFlagBehavior::Error, Key, Val1);
   EXPECT_EQ(Val1, M.getModuleFlag(Key));
   M.setModuleFlag(Module::ModFlagBehavior::Error, Key, Val2);
   EXPECT_EQ(Val2, M.getModuleFlag(Key));
 }

 const char *IRString = R"IR(
   !llvm.module.flags = !{!0}

   !0 = !{i32 1, !"ProfileSummary", !1}
   !1 = !{!2, !3, !4, !5, !6, !7, !8, !9}
   !2 = !{!"ProfileFormat", !"SampleProfile"}
   !3 = !{!"TotalCount", i64 10000}
   !4 = !{!"MaxCount", i64 10}
   !5 = !{!"MaxInternalCount", i64 1}
   !6 = !{!"MaxFunctionCount", i64 1000}
   !7 = !{!"NumCounts", i64 200}
   !8 = !{!"NumFunctions", i64 3}
   !9 = !{!"DetailedSummary", !10}
   !10 = !{!11, !12, !13}
   !11 = !{i32 10000, i64 1000, i32 1}
   !12 = !{i32 990000, i64 300, i32 10}
   !13 = !{i32 999999, i64 5, i32 100}
 )IR";

 TEST(ModuleTest, setProfileSummary) {
   SMDiagnostic Err;
   LLVMContext Context;
   std::unique_ptr<Module> M = parseAssemblyString(IRString, Err, Context);
   auto *PS = ProfileSummary::getFromMD(M->getProfileSummary(/*IsCS*/ false));
   EXPECT_NE(nullptr, PS);
   EXPECT_FALSE(PS->isPartialProfile());
   PS->setPartialProfile(true);
   M->setProfileSummary(PS->getMD(Context), ProfileSummary::PSK_Sample);
   delete PS;
   PS = ProfileSummary::getFromMD(M->getProfileSummary(/*IsCS*/ false));
   EXPECT_NE(nullptr, PS);
   EXPECT_EQ(true, PS->isPartialProfile());
   delete PS;
 }

 TEST(ModuleTest, setPartialSampleProfileRatio) {
   const char *IRString = R"IR(
   !llvm.module.flags = !{!0}

   !0 = !{i32 1, !"ProfileSummary", !1}
   !1 = !{!2, !3, !4, !5, !6, !7, !8, !9, !10, !11}
   !2 = !{!"ProfileFormat", !"SampleProfile"}
   !3 = !{!"TotalCount", i64 10000}
   !4 = !{!"MaxCount", i64 10}
   !5 = !{!"MaxInternalCount", i64 1}
   !6 = !{!"MaxFunctionCount", i64 1000}
   !7 = !{!"NumCounts", i64 200}
   !8 = !{!"NumFunctions", i64 3}
   !9 = !{!"IsPartialProfile", i64 1}
   !10 = !{!"PartialProfileRatio", double 0.0}
   !11 = !{!"DetailedSummary", !12}
   !12 = !{!13, !14, !15}
   !13 = !{i32 10000, i64 1000, i32 1}
   !14 = !{i32 990000, i64 300, i32 10}
   !15 = !{i32 999999, i64 5, i32 100}
   )IR";

   SMDiagnostic Err;
   LLVMContext Context;
   std::unique_ptr<Module> M = parseAssemblyString(IRString, Err, Context);
   ModuleSummaryIndex Index(/*HaveGVs*/ false);
   const unsigned BlockCount = 100;
   const unsigned NumCounts = 200;
   Index.setBlockCount(BlockCount);
   M->setPartialSampleProfileRatio(Index);
   double Ratio = (double)BlockCount / NumCounts;
   std::unique_ptr<ProfileSummary> ProfileSummary(
       ProfileSummary::getFromMD(M->getProfileSummary(/*IsCS*/ false)));
   EXPECT_EQ(Ratio, ProfileSummary->getPartialProfileRatio());
 }

 TEST(ModuleTest, AliasList) {
   // This tests all Module's functions that interact with Module::AliasList.
   LLVMContext C;
   SMDiagnostic Err;
   LLVMContext Context;
   std::unique_ptr<Module> M = parseAssemblyString(R"(
 declare void @Foo()
 @GA = alias void (), ptr @Foo
 )",
                                                   Err, Context);
   Function *Foo = M->getFunction("Foo");
   auto *GA = M->getNamedAlias("GA");
   EXPECT_EQ(M->alias_size(), 1u);
   auto *NewGA =
       GlobalAlias::create(Foo->getType(), 0, GlobalValue::ExternalLinkage,
                           "NewGA", Foo, /*Parent=*/nullptr);
   EXPECT_EQ(M->alias_size(), 1u);

   M->insertAlias(NewGA);
   EXPECT_EQ(&*std::prev(M->aliases().end()), NewGA);

   M->removeAlias(NewGA);
   EXPECT_EQ(M->alias_size(), 1u);
   M->insertAlias(NewGA);
   EXPECT_EQ(M->alias_size(), 2u);
   EXPECT_EQ(&*std::prev(M->aliases().end()), NewGA);

   auto Range = M->aliases();
   EXPECT_EQ(&*Range.begin(), GA);
   EXPECT_EQ(&*std::next(Range.begin()), NewGA);
   EXPECT_EQ(std::next(Range.begin(), 2), Range.end());

   M->removeAlias(NewGA);
   EXPECT_EQ(M->alias_size(), 1u);

   M->insertAlias(NewGA);
   M->eraseAlias(NewGA);
   EXPECT_EQ(M->alias_size(), 1u);
 }

 TEST(ModuleTest, IFuncList) {
   // This tests all Module's functions that interact with Module::IFuncList.
   LLVMContext C;
   SMDiagnostic Err;
   LLVMContext Context;
   std::unique_ptr<Module> M = parseAssemblyString(R"(
 declare void @Foo()
 @GIF = ifunc void (), ptr @Foo
 )",
                                                   Err, Context);
   Function *Foo = M->getFunction("Foo");
   auto *GIF = M->getNamedIFunc("GIF");
   EXPECT_EQ(M->ifunc_size(), 1u);
   auto *NewGIF =
       GlobalIFunc::create(Foo->getType(), 0, GlobalValue::ExternalLinkage,
                           "NewGIF", Foo, /*Parent=*/nullptr);
   EXPECT_EQ(M->ifunc_size(), 1u);

   M->insertIFunc(NewGIF);
   EXPECT_EQ(&*std::prev(M->ifuncs().end()), NewGIF);

   M->removeIFunc(NewGIF);
   EXPECT_EQ(M->ifunc_size(), 1u);
   M->insertIFunc(NewGIF);
   EXPECT_EQ(M->ifunc_size(), 2u);
   EXPECT_EQ(&*std::prev(M->ifuncs().end()), NewGIF);

   auto Range = M->ifuncs();
   EXPECT_EQ(&*Range.begin(), GIF);
   EXPECT_EQ(&*std::next(Range.begin()), NewGIF);
   EXPECT_EQ(std::next(Range.begin(), 2), Range.end());

   M->removeIFunc(NewGIF);
   EXPECT_EQ(M->ifunc_size(), 1u);

   M->insertIFunc(NewGIF);
   M->eraseIFunc(NewGIF);
   EXPECT_EQ(M->ifunc_size(), 1u);
 }

 TEST(ModuleTest, NamedMDList) {
   // This tests all Module's functions that interact with Module::NamedMDList.
   LLVMContext C;
   SMDiagnostic Err;
   LLVMContext Context;
   auto M = std::make_unique<Module>("M", C);
   NamedMDNode *MDN1 = M->getOrInsertNamedMetadata("MDN1");
   EXPECT_EQ(M->named_metadata_size(), 1u);
   NamedMDNode *MDN2 = M->getOrInsertNamedMetadata("MDN2");
   EXPECT_EQ(M->named_metadata_size(), 2u);
   auto *NewMDN = M->getOrInsertNamedMetadata("NewMDN");
   EXPECT_EQ(M->named_metadata_size(), 3u);

   M->removeNamedMDNode(NewMDN);
   EXPECT_EQ(M->named_metadata_size(), 2u);

   M->insertNamedMDNode(NewMDN);
   EXPECT_EQ(&*std::prev(M->named_metadata().end()), NewMDN);

   M->removeNamedMDNode(NewMDN);
   M->insertNamedMDNode(NewMDN);
   EXPECT_EQ(M->named_metadata_size(), 3u);
   EXPECT_EQ(&*std::prev(M->named_metadata().end()), NewMDN);

   auto Range = M->named_metadata();
   EXPECT_EQ(&*Range.begin(), MDN1);
   EXPECT_EQ(&*std::next(Range.begin(), 1), MDN2);
   EXPECT_EQ(&*std::next(Range.begin(), 2), NewMDN);
   EXPECT_EQ(std::next(Range.begin(), 3), Range.end());

   M->eraseNamedMDNode(NewMDN);
   EXPECT_EQ(M->named_metadata_size(), 2u);
 }

 TEST(ModuleTest, GlobalList) {
   // This tests all Module's functions that interact with Module::GlobalList.
   LLVMContext C;
   SMDiagnostic Err;
   LLVMContext Context;
   std::unique_ptr<Module> M = parseAssemblyString(R"(
 @GV = external global i32
 )",
                                                   Err, Context);
   auto *GV = cast<GlobalVariable>(M->getNamedValue("GV"));
   EXPECT_EQ(M->global_size(), 1u);
   GlobalVariable *NewGV = new GlobalVariable(
       Type::getInt32Ty(C), /*isConstant=*/true, GlobalValue::InternalLinkage,
       /*Initializer=*/nullptr, "NewGV");
   EXPECT_EQ(M->global_size(), 1u);
   // Insert before
   M->insertGlobalVariable(M->globals().begin(), NewGV);
   EXPECT_EQ(M->global_size(), 2u);
   EXPECT_EQ(&*M->globals().begin(), NewGV);
   // Insert at end()
   M->removeGlobalVariable(NewGV);
   EXPECT_EQ(M->global_size(), 1u);
   M->insertGlobalVariable(NewGV);
   EXPECT_EQ(M->global_size(), 2u);
   EXPECT_EQ(&*std::prev(M->globals().end()), NewGV);
   // Check globals()
   auto Range = M->globals();
   EXPECT_EQ(&*Range.begin(), GV);
   EXPECT_EQ(&*std::next(Range.begin()), NewGV);
   EXPECT_EQ(std::next(Range.begin(), 2), Range.end());
   // Check remove
   M->removeGlobalVariable(NewGV);
   EXPECT_EQ(M->global_size(), 1u);
   // Check erase
   M->insertGlobalVariable(NewGV);
   M->eraseGlobalVariable(NewGV);
   EXPECT_EQ(M->global_size(), 1u);
 }

 } // end namespace
	//===- unittests/IR/ModuleTest.cpp - Module unit tests --------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/IR/Module.h"
	#include "llvm/AsmParser/Parser.h"
	#include "llvm/IR/GlobalVariable.h"
	#include "llvm/IR/ModuleSummaryIndex.h"
	#include "llvm/Pass.h"
	#include "llvm/Support/RandomNumberGenerator.h"
	#include "llvm/Support/SourceMgr.h"
	#include "gtest/gtest.h"

	#include <random>

	using namespace llvm;

	namespace {

	bool sortByName(const GlobalVariable &L, const GlobalVariable &R) {
	return L.getName() < R.getName();
	}

	bool sortByNameReverse(const GlobalVariable &L, const GlobalVariable &R) {
	return sortByName(R, L);
	}

	TEST(ModuleTest, sortGlobalsByName) {
	LLVMContext Context;
	for (auto compare : {&sortByName, &sortByNameReverse}) {
	Module M("M", Context);
	Type *T = Type::getInt8Ty(Context);
	GlobalValue::LinkageTypes L = GlobalValue::ExternalLinkage;
	(void)new GlobalVariable(M, T, false, L, nullptr, "A");
	(void)new GlobalVariable(M, T, false, L, nullptr, "F");
	(void)new GlobalVariable(M, T, false, L, nullptr, "G");
	(void)new GlobalVariable(M, T, false, L, nullptr, "E");
	(void)new GlobalVariable(M, T, false, L, nullptr, "B");
	(void)new GlobalVariable(M, T, false, L, nullptr, "H");
	(void)new GlobalVariable(M, T, false, L, nullptr, "C");
	(void)new GlobalVariable(M, T, false, L, nullptr, "D");

	// Sort the globals by name.
	EXPECT_FALSE(std::is_sorted(M.global_begin(), M.global_end(), compare));
	}
	}

	TEST(ModuleTest, randomNumberGenerator) {
	LLVMContext Context;
	static char ID;
	struct DummyPass : ModulePass {
	DummyPass() : ModulePass(ID) {}
	bool runOnModule(Module &) override { return true; }
	} DP;

	Module M("R", Context);

	std::uniform_int_distribution<int> dist;
	const size_t NBCheck = 10;

	std::array<int, NBCheck> RandomStreams[2];
	for (auto &RandomStream : RandomStreams) {
	std::unique_ptr<RandomNumberGenerator> RNG = M.createRNG(DP.getPassName());
	std::generate(RandomStream.begin(), RandomStream.end(),
	[&]() { return dist(*RNG); });
	}

	EXPECT_TRUE(std::equal(RandomStreams[0].begin(), RandomStreams[0].end(),
	RandomStreams[1].begin()));
	}

	TEST(ModuleTest, setModuleFlag) {
	LLVMContext Context;
	Module M("M", Context);
	StringRef Key = "Key";
	Metadata *Val1 = MDString::get(Context, "Val1");
	Metadata *Val2 = MDString::get(Context, "Val2");
	EXPECT_EQ(nullptr, M.getModuleFlag(Key));
	M.setModuleFlag(Module::ModFlagBehavior::Error, Key, Val1);
	EXPECT_EQ(Val1, M.getModuleFlag(Key));
	M.setModuleFlag(Module::ModFlagBehavior::Error, Key, Val2);
	EXPECT_EQ(Val2, M.getModuleFlag(Key));
	}

	const char *IRString = R"IR(
	!llvm.module.flags = !{!0}

	!0 = !{i32 1, !"ProfileSummary", !1}
	!1 = !{!2, !3, !4, !5, !6, !7, !8, !9}
	!2 = !{!"ProfileFormat", !"SampleProfile"}
	!3 = !{!"TotalCount", i64 10000}
	!4 = !{!"MaxCount", i64 10}
	!5 = !{!"MaxInternalCount", i64 1}
	!6 = !{!"MaxFunctionCount", i64 1000}
	!7 = !{!"NumCounts", i64 200}
	!8 = !{!"NumFunctions", i64 3}
	!9 = !{!"DetailedSummary", !10}
	!10 = !{!11, !12, !13}
	!11 = !{i32 10000, i64 1000, i32 1}
	!12 = !{i32 990000, i64 300, i32 10}
	!13 = !{i32 999999, i64 5, i32 100}
	)IR";

	TEST(ModuleTest, setProfileSummary) {
	SMDiagnostic Err;
	LLVMContext Context;
	std::unique_ptr<Module> M = parseAssemblyString(IRString, Err, Context);
	auto PS = ProfileSummary::getFromMD(M->getProfileSummary(/IsCS*/ false));
	EXPECT_NE(nullptr, PS);
	EXPECT_FALSE(PS->isPartialProfile());
	PS->setPartialProfile(true);
	M->setProfileSummary(PS->getMD(Context), ProfileSummary::PSK_Sample);
	delete PS;
	PS = ProfileSummary::getFromMD(M->getProfileSummary(/IsCS/ false));
	EXPECT_NE(nullptr, PS);
	EXPECT_EQ(true, PS->isPartialProfile());
	delete PS;
	}

	TEST(ModuleTest, setPartialSampleProfileRatio) {
	const char *IRString = R"IR(
	!llvm.module.flags = !{!0}

	!0 = !{i32 1, !"ProfileSummary", !1}
	!1 = !{!2, !3, !4, !5, !6, !7, !8, !9, !10, !11}
	!2 = !{!"ProfileFormat", !"SampleProfile"}
	!3 = !{!"TotalCount", i64 10000}
	!4 = !{!"MaxCount", i64 10}
	!5 = !{!"MaxInternalCount", i64 1}
	!6 = !{!"MaxFunctionCount", i64 1000}
	!7 = !{!"NumCounts", i64 200}
	!8 = !{!"NumFunctions", i64 3}
	!9 = !{!"IsPartialProfile", i64 1}
	!10 = !{!"PartialProfileRatio", double 0.0}
	!11 = !{!"DetailedSummary", !12}
	!12 = !{!13, !14, !15}
	!13 = !{i32 10000, i64 1000, i32 1}
	!14 = !{i32 990000, i64 300, i32 10}
	!15 = !{i32 999999, i64 5, i32 100}
	)IR";

	SMDiagnostic Err;
	LLVMContext Context;
	std::unique_ptr<Module> M = parseAssemblyString(IRString, Err, Context);
	ModuleSummaryIndex Index(/HaveGVs/ false);
	const unsigned BlockCount = 100;
	const unsigned NumCounts = 200;
	Index.setBlockCount(BlockCount);
	M->setPartialSampleProfileRatio(Index);
	double Ratio = (double)BlockCount / NumCounts;
	std::unique_ptr<ProfileSummary> ProfileSummary(
	ProfileSummary::getFromMD(M->getProfileSummary(/IsCS/ false)));
	EXPECT_EQ(Ratio, ProfileSummary->getPartialProfileRatio());
	}

	TEST(ModuleTest, AliasList) {
	// This tests all Module's functions that interact with Module::AliasList.
	LLVMContext C;
	SMDiagnostic Err;
	LLVMContext Context;
	std::unique_ptr<Module> M = parseAssemblyString(R"(
	declare void @Foo()
	@GA = alias void (), ptr @Foo
	)",
	Err, Context);
	Function *Foo = M->getFunction("Foo");
	auto *GA = M->getNamedAlias("GA");
	EXPECT_EQ(M->alias_size(), 1u);
	auto *NewGA =
	GlobalAlias::create(Foo->getType(), 0, GlobalValue::ExternalLinkage,
	"NewGA", Foo, /Parent=/nullptr);
	EXPECT_EQ(M->alias_size(), 1u);

	M->insertAlias(NewGA);
	EXPECT_EQ(&*std::prev(M->aliases().end()), NewGA);

	M->removeAlias(NewGA);
	EXPECT_EQ(M->alias_size(), 1u);
	M->insertAlias(NewGA);
	EXPECT_EQ(M->alias_size(), 2u);
	EXPECT_EQ(&*std::prev(M->aliases().end()), NewGA);

	auto Range = M->aliases();
	EXPECT_EQ(&*Range.begin(), GA);
	EXPECT_EQ(&*std::next(Range.begin()), NewGA);
	EXPECT_EQ(std::next(Range.begin(), 2), Range.end());

	M->removeAlias(NewGA);
	EXPECT_EQ(M->alias_size(), 1u);

	M->insertAlias(NewGA);
	M->eraseAlias(NewGA);
	EXPECT_EQ(M->alias_size(), 1u);
	}

	TEST(ModuleTest, IFuncList) {
	// This tests all Module's functions that interact with Module::IFuncList.
	LLVMContext C;
	SMDiagnostic Err;
	LLVMContext Context;
	std::unique_ptr<Module> M = parseAssemblyString(R"(
	declare void @Foo()
	@GIF = ifunc void (), ptr @Foo
	)",
	Err, Context);
	Function *Foo = M->getFunction("Foo");
	auto *GIF = M->getNamedIFunc("GIF");
	EXPECT_EQ(M->ifunc_size(), 1u);
	auto *NewGIF =
	GlobalIFunc::create(Foo->getType(), 0, GlobalValue::ExternalLinkage,
	"NewGIF", Foo, /Parent=/nullptr);
	EXPECT_EQ(M->ifunc_size(), 1u);

	M->insertIFunc(NewGIF);
	EXPECT_EQ(&*std::prev(M->ifuncs().end()), NewGIF);

	M->removeIFunc(NewGIF);
	EXPECT_EQ(M->ifunc_size(), 1u);
	M->insertIFunc(NewGIF);
	EXPECT_EQ(M->ifunc_size(), 2u);
	EXPECT_EQ(&*std::prev(M->ifuncs().end()), NewGIF);

	auto Range = M->ifuncs();
	EXPECT_EQ(&*Range.begin(), GIF);
	EXPECT_EQ(&*std::next(Range.begin()), NewGIF);
	EXPECT_EQ(std::next(Range.begin(), 2), Range.end());

	M->removeIFunc(NewGIF);
	EXPECT_EQ(M->ifunc_size(), 1u);

	M->insertIFunc(NewGIF);
	M->eraseIFunc(NewGIF);
	EXPECT_EQ(M->ifunc_size(), 1u);
	}

	TEST(ModuleTest, NamedMDList) {
	// This tests all Module's functions that interact with Module::NamedMDList.
	LLVMContext C;
	SMDiagnostic Err;
	LLVMContext Context;
	auto M = std::make_unique<Module>("M", C);
	NamedMDNode *MDN1 = M->getOrInsertNamedMetadata("MDN1");
	EXPECT_EQ(M->named_metadata_size(), 1u);
	NamedMDNode *MDN2 = M->getOrInsertNamedMetadata("MDN2");
	EXPECT_EQ(M->named_metadata_size(), 2u);
	auto *NewMDN = M->getOrInsertNamedMetadata("NewMDN");
	EXPECT_EQ(M->named_metadata_size(), 3u);

	M->removeNamedMDNode(NewMDN);
	EXPECT_EQ(M->named_metadata_size(), 2u);

	M->insertNamedMDNode(NewMDN);
	EXPECT_EQ(&*std::prev(M->named_metadata().end()), NewMDN);

	M->removeNamedMDNode(NewMDN);
	M->insertNamedMDNode(NewMDN);
	EXPECT_EQ(M->named_metadata_size(), 3u);
	EXPECT_EQ(&*std::prev(M->named_metadata().end()), NewMDN);

	auto Range = M->named_metadata();
	EXPECT_EQ(&*Range.begin(), MDN1);
	EXPECT_EQ(&*std::next(Range.begin(), 1), MDN2);
	EXPECT_EQ(&*std::next(Range.begin(), 2), NewMDN);
	EXPECT_EQ(std::next(Range.begin(), 3), Range.end());

	M->eraseNamedMDNode(NewMDN);
	EXPECT_EQ(M->named_metadata_size(), 2u);
	}

	TEST(ModuleTest, GlobalList) {
	// This tests all Module's functions that interact with Module::GlobalList.
	LLVMContext C;
	SMDiagnostic Err;
	LLVMContext Context;
	std::unique_ptr<Module> M = parseAssemblyString(R"(
	@GV = external global i32
	)",
	Err, Context);
	auto *GV = cast<GlobalVariable>(M->getNamedValue("GV"));
	EXPECT_EQ(M->global_size(), 1u);
	GlobalVariable *NewGV = new GlobalVariable(
	Type::getInt32Ty(C), /isConstant=/true, GlobalValue::InternalLinkage,
	/Initializer=/nullptr, "NewGV");
	EXPECT_EQ(M->global_size(), 1u);
	// Insert before
	M->insertGlobalVariable(M->globals().begin(), NewGV);
	EXPECT_EQ(M->global_size(), 2u);
	EXPECT_EQ(&*M->globals().begin(), NewGV);
	// Insert at end()
	M->removeGlobalVariable(NewGV);
	EXPECT_EQ(M->global_size(), 1u);
	M->insertGlobalVariable(NewGV);
	EXPECT_EQ(M->global_size(), 2u);
	EXPECT_EQ(&*std::prev(M->globals().end()), NewGV);
	// Check globals()
	auto Range = M->globals();
	EXPECT_EQ(&*Range.begin(), GV);
	EXPECT_EQ(&*std::next(Range.begin()), NewGV);
	EXPECT_EQ(std::next(Range.begin(), 2), Range.end());
	// Check remove
	M->removeGlobalVariable(NewGV);
	EXPECT_EQ(M->global_size(), 1u);
	// Check erase
	M->insertGlobalVariable(NewGV);
	M->eraseGlobalVariable(NewGV);
	EXPECT_EQ(M->global_size(), 1u);
	}

	} // end namespace