Rename TargetInfo -> LinkingContext.

Also change some local variable names: "ti" -> "context" and
"_targetInfo" -> "_context".

Differential Revision: http://llvm-reviews.chandlerc.com/D1301

llvm-svn: 187823

5 files changed, 124 insertions, 132 deletions

diff --git a/lld/unittests/CoreTests/RangeTest.cpp b/lld/unittests/CoreTests/RangeTest.cpp
index 37a8d764149..18147ef74b2 100644
--- a/lld/unittests/CoreTests/RangeTest.cpp
+++ b/lld/unittests/CoreTests/RangeTest.cpp
@@ -108,7 +108,7 @@ TEST(Range, passing) {
   // MSVC Can't compile make_ptr_range.
 #ifndef _MSC_VER
   static_assert(
-      std::is_same<decltype(make_ptr_range(v)), lld::range<int *> >::value,
+      std::is_same<decltype(make_ptr_range(v)), lld::range<int *>>::value,
       "make_ptr_range should return a range of pointers");
   takes_range(make_ptr_range(v));
   takes_range(make_ptr_range(implicit_cast<const std::vector<int> &>(v)));
@@ -185,12 +185,12 @@ TEST(Range, slice) {
   // -fsanitize=undefined complains about this, but only if optimizations are
   // enabled.
 #if 0
-  test_slice<std::forward_list<int> >();
+  test_slice<std::forward_list<int>>();
 #endif
-  test_slice<std::list<int> >();
-  // This doesn't build with libstdc++ 4.7
+  test_slice<std::list<int>>();
+// This doesn't build with libstdc++ 4.7
 #if 0
-  test_slice<std::deque<int> >();
+  test_slice<std::deque<int>>();
 #endif
 }
 
@@ -204,7 +204,7 @@ TEST(Range, istream_range) {
   // MSVC interprets input as a function declaration if you don't declare start
   // and instead directly pass std::istream_iterator<int>(stream).
   auto start = std::istream_iterator<int>(stream);
-  lld::range<std::istream_iterator<int> > input(
+  lld::range<std::istream_iterator<int>> input(
       start, std::istream_iterator<int>());
   EXPECT_TRUE(input.front() == 1);
   input.pop_front();
diff --git a/lld/unittests/DriverTests/DarwinLdDriverTest.cpp b/lld/unittests/DriverTests/DarwinLdDriverTest.cpp
index 35d6a679da8..de1b306b25d 100644
--- a/lld/unittests/DriverTests/DarwinLdDriverTest.cpp
+++ b/lld/unittests/DriverTests/DarwinLdDriverTest.cpp
@@ -14,7 +14,7 @@
 
 #include "DriverTest.h"
 
-#include "lld/ReaderWriter/MachOTargetInfo.h"
+#include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "../../lib/ReaderWriter/MachO/MachOFormat.hpp"
 
 using namespace llvm;
@@ -22,17 +22,16 @@ using namespace lld;
 
 namespace {
 
-class DarwinLdParserTest : public ParserTest<DarwinLdDriver, MachOTargetInfo> {
+class DarwinLdParserTest
+    : public ParserTest<DarwinLdDriver, MachOLinkingContext> {
 protected:
-  virtual const TargetInfo *targetInfo() {
-    return &_info;
-  }
+  virtual const LinkingContext *linkingContext() { return &_context; }
 };
 
 TEST_F(DarwinLdParserTest, Basic) {
   EXPECT_FALSE(parse("ld", "foo.o", "bar.o", nullptr));
-  EXPECT_FALSE(_info.allowRemainingUndefines());
-  EXPECT_FALSE(_info.deadStrip());
+  EXPECT_FALSE(_context.allowRemainingUndefines());
+  EXPECT_FALSE(_context.deadStrip());
   EXPECT_EQ(2, inputFileCount());
   EXPECT_EQ("foo.o", inputFile(0));
   EXPECT_EQ("bar.o", inputFile(1));
@@ -40,146 +39,144 @@ TEST_F(DarwinLdParserTest, Basic) {
 
 TEST_F(DarwinLdParserTest, Output) {
   EXPECT_FALSE(parse("ld", "-o", "my.out", "foo.o", nullptr));
-  EXPECT_EQ("my.out", _info.outputPath());
+  EXPECT_EQ("my.out", _context.outputPath());
 }
 
 TEST_F(DarwinLdParserTest, Dylib) {
   EXPECT_FALSE(parse("ld", "-dylib", "foo.o", nullptr));
-  EXPECT_EQ(mach_o::MH_DYLIB, _info.outputFileType());
+  EXPECT_EQ(mach_o::MH_DYLIB, _context.outputFileType());
 }
 
 TEST_F(DarwinLdParserTest, Relocatable) {
   EXPECT_FALSE(parse("ld", "-r", "foo.o", nullptr));
-  EXPECT_EQ(mach_o::MH_OBJECT, _info.outputFileType());
+  EXPECT_EQ(mach_o::MH_OBJECT, _context.outputFileType());
 }
 
 TEST_F(DarwinLdParserTest, Bundle) {
   EXPECT_FALSE(parse("ld", "-bundle", "foo.o", nullptr));
-  EXPECT_EQ(mach_o::MH_BUNDLE, _info.outputFileType());
+  EXPECT_EQ(mach_o::MH_BUNDLE, _context.outputFileType());
 }
 
 TEST_F(DarwinLdParserTest, Preload) {
   EXPECT_FALSE(parse("ld", "-preload", "foo.o", nullptr));
-  EXPECT_EQ(mach_o::MH_PRELOAD, _info.outputFileType());
+  EXPECT_EQ(mach_o::MH_PRELOAD, _context.outputFileType());
 }
 
 TEST_F(DarwinLdParserTest, Static) {
   EXPECT_FALSE(parse("ld", "-static", "foo.o", nullptr));
-  EXPECT_EQ(mach_o::MH_EXECUTE, _info.outputFileType());
+  EXPECT_EQ(mach_o::MH_EXECUTE, _context.outputFileType());
 }
 
 TEST_F(DarwinLdParserTest, Entry) {
   EXPECT_FALSE(parse("ld", "-e", "entryFunc", "foo.o", nullptr));
-  EXPECT_EQ("entryFunc", _info.entrySymbolName());
+  EXPECT_EQ("entryFunc", _context.entrySymbolName());
 }
 
 TEST_F(DarwinLdParserTest, OutputPath) {
   EXPECT_FALSE(parse("ld", "-o", "foo", "foo.o", nullptr));
-  EXPECT_EQ("foo", _info.outputPath());
+  EXPECT_EQ("foo", _context.outputPath());
 }
 
 TEST_F(DarwinLdParserTest, DeadStrip) {
   EXPECT_FALSE(parse("ld", "-dead_strip", "foo.o", nullptr));
-  EXPECT_TRUE(_info.deadStrip());
+  EXPECT_TRUE(_context.deadStrip());
 }
 
 TEST_F(DarwinLdParserTest, DeadStripRootsExe) {
   EXPECT_FALSE(parse("ld", "-dead_strip", "foo.o", nullptr));
-  EXPECT_FALSE(_info.globalsAreDeadStripRoots());
+  EXPECT_FALSE(_context.globalsAreDeadStripRoots());
 }
 
 TEST_F(DarwinLdParserTest, DeadStripRootsDylib) {
   EXPECT_FALSE(parse("ld", "-dylib", "-dead_strip", "foo.o", nullptr));
-  EXPECT_TRUE(_info.globalsAreDeadStripRoots());
+  EXPECT_TRUE(_context.globalsAreDeadStripRoots());
 }
 
 TEST_F(DarwinLdParserTest, ForceLoadArchive) {
   EXPECT_FALSE(parse("ld","-all_load", "foo.o", nullptr));
-  EXPECT_TRUE(_info.forceLoadAllArchives());
+  EXPECT_TRUE(_context.forceLoadAllArchives());
 }
 
 TEST_F(DarwinLdParserTest, NoForceLoadArchive) {
   EXPECT_FALSE(parse("ld", "foo.o", nullptr));
-  EXPECT_FALSE(_info.forceLoadAllArchives());
+  EXPECT_FALSE(_context.forceLoadAllArchives());
 }
 
 TEST_F(DarwinLdParserTest, Arch) {
   EXPECT_FALSE(parse("ld", "-arch", "x86_64", "foo.o", nullptr));
-  EXPECT_EQ(MachOTargetInfo::arch_x86_64, _info.arch());
-  EXPECT_EQ(mach_o::CPU_TYPE_X86_64, _info.getCPUType());
-  EXPECT_EQ(mach_o::CPU_SUBTYPE_X86_64_ALL, _info.getCPUSubType());
+  EXPECT_EQ(MachOLinkingContext::arch_x86_64, _context.arch());
+  EXPECT_EQ(mach_o::CPU_TYPE_X86_64, _context.getCPUType());
+  EXPECT_EQ(mach_o::CPU_SUBTYPE_X86_64_ALL, _context.getCPUSubType());
 }
 
 TEST_F(DarwinLdParserTest, Arch_x86) {
   EXPECT_FALSE(parse("ld", "-arch", "i386", "foo.o", nullptr));
-  EXPECT_EQ(MachOTargetInfo::arch_x86, _info.arch());
-  EXPECT_EQ(mach_o::CPU_TYPE_I386, _info.getCPUType());
-  EXPECT_EQ(mach_o::CPU_SUBTYPE_X86_ALL, _info.getCPUSubType());
+  EXPECT_EQ(MachOLinkingContext::arch_x86, _context.arch());
+  EXPECT_EQ(mach_o::CPU_TYPE_I386, _context.getCPUType());
+  EXPECT_EQ(mach_o::CPU_SUBTYPE_X86_ALL, _context.getCPUSubType());
 }
 
 TEST_F(DarwinLdParserTest, Arch_armv6) {
   EXPECT_FALSE(parse("ld", "-arch", "armv6", "foo.o", nullptr));
-  EXPECT_EQ(MachOTargetInfo::arch_armv6, _info.arch());
-  EXPECT_EQ(mach_o::CPU_TYPE_ARM, _info.getCPUType());
-  EXPECT_EQ(mach_o::CPU_SUBTYPE_ARM_V6, _info.getCPUSubType());
+  EXPECT_EQ(MachOLinkingContext::arch_armv6, _context.arch());
+  EXPECT_EQ(mach_o::CPU_TYPE_ARM, _context.getCPUType());
+  EXPECT_EQ(mach_o::CPU_SUBTYPE_ARM_V6, _context.getCPUSubType());
 }
 
 TEST_F(DarwinLdParserTest, Arch_armv7) {
   EXPECT_FALSE(parse("ld", "-arch", "armv7", "foo.o", nullptr));
-  EXPECT_EQ(MachOTargetInfo::arch_armv7, _info.arch());
-  EXPECT_EQ(mach_o::CPU_TYPE_ARM, _info.getCPUType());
-  EXPECT_EQ(mach_o::CPU_SUBTYPE_ARM_V7, _info.getCPUSubType());
+  EXPECT_EQ(MachOLinkingContext::arch_armv7, _context.arch());
+  EXPECT_EQ(mach_o::CPU_TYPE_ARM, _context.getCPUType());
+  EXPECT_EQ(mach_o::CPU_SUBTYPE_ARM_V7, _context.getCPUSubType());
 }
 
 TEST_F(DarwinLdParserTest, Arch_armv7s) {
   EXPECT_FALSE(parse("ld", "-arch", "armv7s", "foo.o", nullptr));
-  EXPECT_EQ(MachOTargetInfo::arch_armv7s, _info.arch());
-  EXPECT_EQ(mach_o::CPU_TYPE_ARM, _info.getCPUType());
-  EXPECT_EQ(mach_o::CPU_SUBTYPE_ARM_V7S, _info.getCPUSubType());
+  EXPECT_EQ(MachOLinkingContext::arch_armv7s, _context.arch());
+  EXPECT_EQ(mach_o::CPU_TYPE_ARM, _context.getCPUType());
+  EXPECT_EQ(mach_o::CPU_SUBTYPE_ARM_V7S, _context.getCPUSubType());
 }
 
 TEST_F(DarwinLdParserTest, MinMacOSX10_7) {
   EXPECT_FALSE(parse("ld", "-macosx_version_min", "10.7", "foo.o", nullptr));
-  EXPECT_EQ(MachOTargetInfo::OS::macOSX, _info.os());
-  EXPECT_TRUE(_info.minOS("10.7", ""));
-  EXPECT_FALSE(_info.minOS("10.8", ""));
+  EXPECT_EQ(MachOLinkingContext::OS::macOSX, _context.os());
+  EXPECT_TRUE(_context.minOS("10.7", ""));
+  EXPECT_FALSE(_context.minOS("10.8", ""));
 }
 
 TEST_F(DarwinLdParserTest, MinMacOSX10_8) {
   EXPECT_FALSE(parse("ld", "-macosx_version_min", "10.8.3", "foo.o", nullptr));
-  EXPECT_EQ(MachOTargetInfo::OS::macOSX, _info.os());
-  EXPECT_TRUE(_info.minOS("10.7", ""));
-  EXPECT_TRUE(_info.minOS("10.8", ""));
+  EXPECT_EQ(MachOLinkingContext::OS::macOSX, _context.os());
+  EXPECT_TRUE(_context.minOS("10.7", ""));
+  EXPECT_TRUE(_context.minOS("10.8", ""));
 }
 
 TEST_F(DarwinLdParserTest, iOS5) {
   EXPECT_FALSE(parse("ld", "-ios_version_min", "5.0", "foo.o", nullptr));
-  EXPECT_EQ(MachOTargetInfo::OS::iOS, _info.os());
-  EXPECT_TRUE(_info.minOS("", "5.0"));
-  EXPECT_FALSE(_info.minOS("", "6.0"));
+  EXPECT_EQ(MachOLinkingContext::OS::iOS, _context.os());
+  EXPECT_TRUE(_context.minOS("", "5.0"));
+  EXPECT_FALSE(_context.minOS("", "6.0"));
 }
 
 TEST_F(DarwinLdParserTest, iOS6) {
   EXPECT_FALSE(parse("ld", "-ios_version_min", "6.0", "foo.o", nullptr));
-  EXPECT_EQ(MachOTargetInfo::OS::iOS, _info.os());
-  EXPECT_TRUE(_info.minOS("", "5.0"));
-  EXPECT_TRUE(_info.minOS("", "6.0"));
+  EXPECT_EQ(MachOLinkingContext::OS::iOS, _context.os());
+  EXPECT_TRUE(_context.minOS("", "5.0"));
+  EXPECT_TRUE(_context.minOS("", "6.0"));
 }
 
 TEST_F(DarwinLdParserTest, iOS_Simulator5) {
   EXPECT_FALSE(parse("ld", "-ios_simulator_version_min", "5.0", "a.o", nullptr));
-  EXPECT_EQ(MachOTargetInfo::OS::iOS_simulator, _info.os());
-  EXPECT_TRUE(_info.minOS("", "5.0"));
-  EXPECT_FALSE(_info.minOS("", "6.0"));
+  EXPECT_EQ(MachOLinkingContext::OS::iOS_simulator, _context.os());
+  EXPECT_TRUE(_context.minOS("", "5.0"));
+  EXPECT_FALSE(_context.minOS("", "6.0"));
 }
 
 TEST_F(DarwinLdParserTest, iOS_Simulator6) {
   EXPECT_FALSE(parse("ld", "-ios_simulator_version_min", "6.0", "a.o", nullptr));
-  EXPECT_EQ(MachOTargetInfo::OS::iOS_simulator, _info.os());
-  EXPECT_TRUE(_info.minOS("", "5.0"));
-  EXPECT_TRUE(_info.minOS("", "6.0"));
+  EXPECT_EQ(MachOLinkingContext::OS::iOS_simulator, _context.os());
+  EXPECT_TRUE(_context.minOS("", "5.0"));
+  EXPECT_TRUE(_context.minOS("", "6.0"));
 }
 
-
-
 }  // end anonymous namespace
diff --git a/lld/unittests/DriverTests/DriverTest.h b/lld/unittests/DriverTests/DriverTest.h
index d3acc3e7da2..1090828ddd0 100644
--- a/lld/unittests/DriverTests/DriverTest.h
+++ b/lld/unittests/DriverTests/DriverTest.h
@@ -25,18 +25,16 @@ template<typename D, typename T>
 class ParserTest : public testing::Test {
 protected:
 
-  virtual const TargetInfo *targetInfo() = 0;
+  virtual const LinkingContext *linkingContext() = 0;
 
   std::string &errorMessage() { return  _errorMessage; }
 
   // Convenience method for getting number of input files.
-  int inputFileCount() {
-    return targetInfo()->inputFiles().size();
-  }
+  int inputFileCount() { return linkingContext()->inputFiles().size(); }
 
   // Convenience method for getting i'th input files name.
   std::string inputFile(unsigned index) {
-    return targetInfo()->inputFiles()[index].getPath().str();
+    return linkingContext()->inputFiles()[index].getPath().str();
   }
 
   // For unit tests to call driver with various command lines.
@@ -52,10 +50,10 @@ protected:
 
     // Call the parser.
     raw_string_ostream os(_errorMessage);
-    return D::parse(vec.size(), &vec[0], _info, os);
+    return D::parse(vec.size(), &vec[0], _context, os);
   }
 
-  T           _info;
+  T _context;
   std::string _errorMessage;
 };
 
diff --git a/lld/unittests/DriverTests/GnuLdDriverTest.cpp b/lld/unittests/DriverTests/GnuLdDriverTest.cpp
index 00cfa9558c1..fb2af7cb0c7 100644
--- a/lld/unittests/DriverTests/GnuLdDriverTest.cpp
+++ b/lld/unittests/DriverTests/GnuLdDriverTest.cpp
@@ -14,43 +14,41 @@
 
 #include "DriverTest.h"
 
-#include "lld/ReaderWriter/ELFTargetInfo.h"
+#include "lld/ReaderWriter/ELFLinkingContext.h"
 
 using namespace llvm;
 using namespace lld;
 
 namespace {
 
-class GnuLdParserTest : public ParserTest<
-                                GnuLdDriver, std::unique_ptr<ELFTargetInfo> > {
+class GnuLdParserTest
+    : public ParserTest<GnuLdDriver, std::unique_ptr<ELFLinkingContext>> {
 protected:
-  virtual const TargetInfo *targetInfo() {
-    return _info.get();
-  }
+  virtual const LinkingContext *linkingContext() { return _context.get(); }
 };
 
 TEST_F(GnuLdParserTest, Empty) {
   EXPECT_TRUE(parse("ld", nullptr));
-  EXPECT_EQ(targetInfo(), nullptr);
+  EXPECT_EQ(linkingContext(), nullptr);
   EXPECT_EQ("No input files\n", errorMessage());
 }
 
 TEST_F(GnuLdParserTest, Basic) {
   EXPECT_FALSE(parse("ld", "infile.o", nullptr));
-  EXPECT_NE(targetInfo(), nullptr);
-  EXPECT_EQ("a.out", targetInfo()->outputPath());
+  EXPECT_NE(linkingContext(), nullptr);
+  EXPECT_EQ("a.out", linkingContext()->outputPath());
   EXPECT_EQ(1, inputFileCount());
   EXPECT_EQ("infile.o", inputFile(0));
-  EXPECT_FALSE(_info->outputYAML());
+  EXPECT_FALSE(_context->outputYAML());
 }
 
 TEST_F(GnuLdParserTest, ManyOptions) {
   EXPECT_FALSE(parse("ld", "-entry", "_start", "-o", "outfile",
         "-emit-yaml", "infile.o", nullptr));
-  EXPECT_NE(targetInfo(), nullptr);
-  EXPECT_EQ("outfile", targetInfo()->outputPath());
-  EXPECT_EQ("_start", targetInfo()->entrySymbolName());
-  EXPECT_TRUE(_info->outputYAML());
+  EXPECT_NE(linkingContext(), nullptr);
+  EXPECT_EQ("outfile", linkingContext()->outputPath());
+  EXPECT_EQ("_start", linkingContext()->entrySymbolName());
+  EXPECT_TRUE(_context->outputYAML());
 }
 
 }  // end anonymous namespace
diff --git a/lld/unittests/DriverTests/WinLinkDriverTest.cpp b/lld/unittests/DriverTests/WinLinkDriverTest.cpp
index d32f22259b4..d048c89c1d2 100644
--- a/lld/unittests/DriverTests/WinLinkDriverTest.cpp
+++ b/lld/unittests/DriverTests/WinLinkDriverTest.cpp
@@ -14,7 +14,7 @@
 
 #include "DriverTest.h"
 
-#include "lld/ReaderWriter/PECOFFTargetInfo.h"
+#include "lld/ReaderWriter/PECOFFLinkingContext.h"
 #include "llvm/Support/COFF.h"
 
 #include <vector>
@@ -24,58 +24,57 @@ using namespace lld;
 
 namespace {
 
-class WinLinkParserTest : public ParserTest<WinLinkDriver, PECOFFTargetInfo> {
+class WinLinkParserTest
+    : public ParserTest<WinLinkDriver, PECOFFLinkingContext> {
 protected:
-  virtual const TargetInfo *targetInfo() {
-    return &_info;
-  }
+  virtual const LinkingContext *linkingContext() { return &_context; }
 };
 
 TEST_F(WinLinkParserTest, Basic) {
   EXPECT_FALSE(parse("link.exe", "/subsystem:console", "/out:a.exe",
         "-entry:_start", "a.obj", "b.obj", "c.obj", nullptr));
-  EXPECT_EQ(llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_CUI, _info.getSubsystem());
-  EXPECT_EQ("a.exe", _info.outputPath());
-  EXPECT_EQ("_start", _info.entrySymbolName());
+  EXPECT_EQ(llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_CUI, _context.getSubsystem());
+  EXPECT_EQ("a.exe", _context.outputPath());
+  EXPECT_EQ("_start", _context.entrySymbolName());
   EXPECT_EQ(3, inputFileCount());
   EXPECT_EQ("a.obj", inputFile(0));
   EXPECT_EQ("b.obj", inputFile(1));
   EXPECT_EQ("c.obj", inputFile(2));
-  EXPECT_TRUE(_info.getInputSearchPaths().empty());
+  EXPECT_TRUE(_context.getInputSearchPaths().empty());
 
   // Unspecified flags will have default values.
-  EXPECT_EQ(6, _info.getMinOSVersion().majorVersion);
-  EXPECT_EQ(0, _info.getMinOSVersion().minorVersion);
-  EXPECT_EQ(0x400000U, _info.getBaseAddress());
-  EXPECT_EQ(1024 * 1024U, _info.getStackReserve());
-  EXPECT_EQ(4096U, _info.getStackCommit());
-  EXPECT_FALSE(_info.allowRemainingUndefines());
-  EXPECT_TRUE(_info.isNxCompat());
-  EXPECT_FALSE(_info.getLargeAddressAware());
-  EXPECT_TRUE(_info.getBaseRelocationEnabled());
-  EXPECT_TRUE(_info.isTerminalServerAware());
-  EXPECT_TRUE(_info.initialUndefinedSymbols().empty());
+  EXPECT_EQ(6, _context.getMinOSVersion().majorVersion);
+  EXPECT_EQ(0, _context.getMinOSVersion().minorVersion);
+  EXPECT_EQ(0x400000U, _context.getBaseAddress());
+  EXPECT_EQ(1024 * 1024U, _context.getStackReserve());
+  EXPECT_EQ(4096U, _context.getStackCommit());
+  EXPECT_FALSE(_context.allowRemainingUndefines());
+  EXPECT_TRUE(_context.isNxCompat());
+  EXPECT_FALSE(_context.getLargeAddressAware());
+  EXPECT_TRUE(_context.getBaseRelocationEnabled());
+  EXPECT_TRUE(_context.isTerminalServerAware());
+  EXPECT_TRUE(_context.initialUndefinedSymbols().empty());
 }
 
 TEST_F(WinLinkParserTest, UnixStyleOption) {
   EXPECT_FALSE(parse("link.exe", "-subsystem", "console", "-out", "a.exe",
                      "a.obj", nullptr));
-  EXPECT_EQ(llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_CUI, _info.getSubsystem());
-  EXPECT_EQ("a.exe", _info.outputPath());
+  EXPECT_EQ(llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_CUI, _context.getSubsystem());
+  EXPECT_EQ("a.exe", _context.outputPath());
   EXPECT_EQ(1, inputFileCount());
   EXPECT_EQ("a.obj", inputFile(0));
 }
 
 TEST_F(WinLinkParserTest, Mllvm) {
   EXPECT_FALSE(parse("link.exe", "-mllvm", "-debug", "a.obj", nullptr));
-  const std::vector<const char *> &options = _info.llvmOptions();
+  const std::vector<const char *> &options = _context.llvmOptions();
   EXPECT_EQ(1U, options.size());
   EXPECT_EQ("-debug", options[0]);
 }
 
 TEST_F(WinLinkParserTest, NoFileExtension) {
   EXPECT_FALSE(parse("link.exe", "foo", "bar", nullptr));
-  EXPECT_EQ("foo.exe", _info.outputPath());
+  EXPECT_EQ("foo.exe", _context.outputPath());
   EXPECT_EQ(2, inputFileCount());
   EXPECT_EQ("foo.obj", inputFile(0));
   EXPECT_EQ("bar.obj", inputFile(1));
@@ -83,7 +82,7 @@ TEST_F(WinLinkParserTest, NoFileExtension) {
 
 TEST_F(WinLinkParserTest, NonStandardFileExtension) {
   EXPECT_FALSE(parse("link.exe", "foo.o", nullptr));
-  EXPECT_EQ("foo.exe", _info.outputPath());
+  EXPECT_EQ("foo.exe", _context.outputPath());
   EXPECT_EQ(1, inputFileCount());
   EXPECT_EQ("foo.o", inputFile(0));
 }
@@ -91,7 +90,7 @@ TEST_F(WinLinkParserTest, NonStandardFileExtension) {
 TEST_F(WinLinkParserTest, Libpath) {
   EXPECT_FALSE(parse("link.exe", "/libpath:dir1", "/libpath:dir2",
                      "a.obj", nullptr));
-  const std::vector<StringRef> &paths = _info.getInputSearchPaths();
+  const std::vector<StringRef> &paths = _context.getInputSearchPaths();
   EXPECT_EQ(2U, paths.size());
   EXPECT_EQ("dir1", paths[0]);
   EXPECT_EQ("dir2", paths[1]);
@@ -99,16 +98,16 @@ TEST_F(WinLinkParserTest, Libpath) {
 
 TEST_F(WinLinkParserTest, MinMajorOSVersion) {
   EXPECT_FALSE(parse("link.exe", "/subsystem:windows,3", "foo.o", nullptr));
-  EXPECT_EQ(llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_GUI, _info.getSubsystem());
-  EXPECT_EQ(3, _info.getMinOSVersion().majorVersion);
-  EXPECT_EQ(0, _info.getMinOSVersion().minorVersion);
+  EXPECT_EQ(llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_GUI, _context.getSubsystem());
+  EXPECT_EQ(3, _context.getMinOSVersion().majorVersion);
+  EXPECT_EQ(0, _context.getMinOSVersion().minorVersion);
 }
 
 TEST_F(WinLinkParserTest, MinMajorMinorOSVersion) {
   EXPECT_FALSE(parse("link.exe", "/subsystem:windows,3.1", "foo.o", nullptr));
-  EXPECT_EQ(llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_GUI, _info.getSubsystem());
-  EXPECT_EQ(3, _info.getMinOSVersion().majorVersion);
-  EXPECT_EQ(1, _info.getMinOSVersion().minorVersion);
+  EXPECT_EQ(llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_GUI, _context.getSubsystem());
+  EXPECT_EQ(3, _context.getMinOSVersion().majorVersion);
+  EXPECT_EQ(1, _context.getMinOSVersion().minorVersion);
 }
 
 TEST_F(WinLinkParserTest, DefaultLib) {
@@ -122,76 +121,76 @@ TEST_F(WinLinkParserTest, DefaultLib) {
 
 TEST_F(WinLinkParserTest, Base) {
   EXPECT_FALSE(parse("link.exe", "/base:8388608", "a.obj", nullptr));
-  EXPECT_EQ(0x800000U, _info.getBaseAddress());
+  EXPECT_EQ(0x800000U, _context.getBaseAddress());
 }
 
 TEST_F(WinLinkParserTest, StackReserve) {
   EXPECT_FALSE(parse("link.exe", "/stack:8192", "a.obj", nullptr));
-  EXPECT_EQ(8192U, _info.getStackReserve());
-  EXPECT_EQ(4096U, _info.getStackCommit());
+  EXPECT_EQ(8192U, _context.getStackReserve());
+  EXPECT_EQ(4096U, _context.getStackCommit());
 }
 
 TEST_F(WinLinkParserTest, StackReserveAndCommit) {
   EXPECT_FALSE(parse("link.exe", "/stack:16384,8192", "a.obj", nullptr));
-  EXPECT_EQ(16384U, _info.getStackReserve());
-  EXPECT_EQ(8192U, _info.getStackCommit());
+  EXPECT_EQ(16384U, _context.getStackReserve());
+  EXPECT_EQ(8192U, _context.getStackCommit());
 }
 
 TEST_F(WinLinkParserTest, HeapReserve) {
   EXPECT_FALSE(parse("link.exe", "/heap:8192", "a.obj", nullptr));
-  EXPECT_EQ(8192U, _info.getHeapReserve());
-  EXPECT_EQ(4096U, _info.getHeapCommit());
+  EXPECT_EQ(8192U, _context.getHeapReserve());
+  EXPECT_EQ(4096U, _context.getHeapCommit());
 }
 
 TEST_F(WinLinkParserTest, HeapReserveAndCommit) {
   EXPECT_FALSE(parse("link.exe", "/heap:16384,8192", "a.obj", nullptr));
-  EXPECT_EQ(16384U, _info.getHeapReserve());
-  EXPECT_EQ(8192U, _info.getHeapCommit());
+  EXPECT_EQ(16384U, _context.getHeapReserve());
+  EXPECT_EQ(8192U, _context.getHeapCommit());
 }
 
 TEST_F(WinLinkParserTest, Force) {
   EXPECT_FALSE(parse("link.exe", "/force", "a.obj", nullptr));
-  EXPECT_TRUE(_info.allowRemainingUndefines());
+  EXPECT_TRUE(_context.allowRemainingUndefines());
 }
 
 TEST_F(WinLinkParserTest, NoNxCompat) {
   EXPECT_FALSE(parse("link.exe", "/nxcompat:no", "a.obj", nullptr));
-  EXPECT_FALSE(_info.isNxCompat());
+  EXPECT_FALSE(_context.isNxCompat());
 }
 
 TEST_F(WinLinkParserTest, LargeAddressAware) {
   EXPECT_FALSE(parse("link.exe", "/largeaddressaware", "a.obj", nullptr));
-  EXPECT_TRUE(_info.getLargeAddressAware());
+  EXPECT_TRUE(_context.getLargeAddressAware());
 }
 
 TEST_F(WinLinkParserTest, NoLargeAddressAware) {
   EXPECT_FALSE(parse("link.exe", "/largeaddressaware:no", "a.obj", nullptr));
-  EXPECT_FALSE(_info.getLargeAddressAware());
+  EXPECT_FALSE(_context.getLargeAddressAware());
 }
 
 TEST_F(WinLinkParserTest, Fixed) {
   EXPECT_FALSE(parse("link.exe", "/fixed", "a.out", nullptr));
-  EXPECT_FALSE(_info.getBaseRelocationEnabled());
+  EXPECT_FALSE(_context.getBaseRelocationEnabled());
 }
 
 TEST_F(WinLinkParserTest, NoFixed) {
   EXPECT_FALSE(parse("link.exe", "/fixed:no", "a.out", nullptr));
-  EXPECT_TRUE(_info.getBaseRelocationEnabled());
+  EXPECT_TRUE(_context.getBaseRelocationEnabled());
 }
 
 TEST_F(WinLinkParserTest, TerminalServerAware) {
   EXPECT_FALSE(parse("link.exe", "/tsaware", "a.out", nullptr));
-  EXPECT_TRUE(_info.isTerminalServerAware());
+  EXPECT_TRUE(_context.isTerminalServerAware());
 }
 
 TEST_F(WinLinkParserTest, NoTerminalServerAware) {
   EXPECT_FALSE(parse("link.exe", "/tsaware:no", "a.out", nullptr));
-  EXPECT_FALSE(_info.isTerminalServerAware());
+  EXPECT_FALSE(_context.isTerminalServerAware());
 }
 
 TEST_F(WinLinkParserTest, Include) {
   EXPECT_FALSE(parse("link.exe", "/include:foo", "a.out", nullptr));
-  auto symbols = _info.initialUndefinedSymbols();
+  auto symbols = _context.initialUndefinedSymbols();
   EXPECT_FALSE(symbols.empty());
   EXPECT_EQ("foo", symbols[0]);
   symbols.pop_front();