1 files changed, 25 insertions, 25 deletions

diff --git a/lld/unittests/DriverTests/GnuLdDriverTest.cpp b/lld/unittests/DriverTests/GnuLdDriverTest.cpp
index a736f5cee2a..9a24aadcedb 100644
--- a/lld/unittests/DriverTests/GnuLdDriverTest.cpp
+++ b/lld/unittests/DriverTests/GnuLdDriverTest.cpp
@@ -24,7 +24,7 @@ namespace {
 class GnuLdParserTest
     : public ParserTest<GnuLdDriver, std::unique_ptr<ELFLinkingContext>> {
 protected:
-  const LinkingContext *linkingContext() override { return _context.get(); }
+  const LinkingContext *linkingContext() override { return _ctx.get(); }
 };
 
 class LinkerScriptTest : public testing::Test {
@@ -59,121 +59,121 @@ TEST_F(GnuLdParserTest, Empty) {
 
 TEST_F(GnuLdParserTest, Output) {
   EXPECT_TRUE(parse("ld", "a.o", "-o", "foo", nullptr));
-  EXPECT_EQ("foo", _context->outputPath());
+  EXPECT_EQ("foo", _ctx->outputPath());
 }
 
 TEST_F(GnuLdParserTest, OutputDefault) {
   EXPECT_TRUE(parse("ld", "abc.o", nullptr));
-  EXPECT_EQ("a.out", _context->outputPath());
+  EXPECT_EQ("a.out", _ctx->outputPath());
 }
 
 // --noinhibit-exec
 
 TEST_F(GnuLdParserTest, NoinhibitExec) {
   EXPECT_TRUE(parse("ld", "a.o", "--noinhibit-exec", nullptr));
-  EXPECT_TRUE(_context->allowRemainingUndefines());
+  EXPECT_TRUE(_ctx->allowRemainingUndefines());
 }
 
 // --entry
 
 TEST_F(GnuLdParserTest, Entry) {
   EXPECT_TRUE(parse("ld", "a.o", "--entry", "foo", nullptr));
-  EXPECT_EQ("foo", _context->entrySymbolName());
+  EXPECT_EQ("foo", _ctx->entrySymbolName());
 }
 
 TEST_F(GnuLdParserTest, EntryShort) {
   EXPECT_TRUE(parse("ld", "a.o", "-e", "foo", nullptr));
-  EXPECT_EQ("foo", _context->entrySymbolName());
+  EXPECT_EQ("foo", _ctx->entrySymbolName());
 }
 
 TEST_F(GnuLdParserTest, EntryJoined) {
   EXPECT_TRUE(parse("ld", "a.o", "--entry=foo", nullptr));
-  EXPECT_EQ("foo", _context->entrySymbolName());
+  EXPECT_EQ("foo", _ctx->entrySymbolName());
 }
 
 // --export-dynamic
 
 TEST_F(GnuLdParserTest, ExportDynamic) {
   EXPECT_TRUE(parse("ld", "a.o", "--export-dynamic", nullptr));
-  EXPECT_TRUE(_context->shouldExportDynamic());
+  EXPECT_TRUE(_ctx->shouldExportDynamic());
 }
 
 TEST_F(GnuLdParserTest, NoExportDynamic) {
   EXPECT_TRUE(parse("ld", "a.o", "--no-export-dynamic", nullptr));
-  EXPECT_FALSE(_context->shouldExportDynamic());
+  EXPECT_FALSE(_ctx->shouldExportDynamic());
 }
 
 // --init
 
 TEST_F(GnuLdParserTest, Init) {
   EXPECT_TRUE(parse("ld", "a.o", "-init", "foo", "-init", "bar", nullptr));
-  EXPECT_EQ("bar", _context->initFunction());
+  EXPECT_EQ("bar", _ctx->initFunction());
 }
 
 TEST_F(GnuLdParserTest, InitJoined) {
   EXPECT_TRUE(parse("ld", "a.o", "-init=foo", nullptr));
-  EXPECT_EQ("foo", _context->initFunction());
+  EXPECT_EQ("foo", _ctx->initFunction());
 }
 
 // --soname
 
 TEST_F(GnuLdParserTest, SOName) {
   EXPECT_TRUE(parse("ld", "a.o", "--soname=foo", nullptr));
-  EXPECT_EQ("foo", _context->sharedObjectName());
+  EXPECT_EQ("foo", _ctx->sharedObjectName());
 }
 
 TEST_F(GnuLdParserTest, SONameSingleDash) {
   EXPECT_TRUE(parse("ld", "a.o", "-soname=foo", nullptr));
-  EXPECT_EQ("foo", _context->sharedObjectName());
+  EXPECT_EQ("foo", _ctx->sharedObjectName());
 }
 
 TEST_F(GnuLdParserTest, SONameH) {
   EXPECT_TRUE(parse("ld", "a.o", "-h", "foo", nullptr));
-  EXPECT_EQ("foo", _context->sharedObjectName());
+  EXPECT_EQ("foo", _ctx->sharedObjectName());
 }
 
 // -rpath
 
 TEST_F(GnuLdParserTest, Rpath) {
   EXPECT_TRUE(parse("ld", "a.o", "-rpath", "foo:bar", nullptr));
-  EXPECT_EQ(2, _context->getRpathList().size());
-  EXPECT_EQ("foo", _context->getRpathList()[0]);
-  EXPECT_EQ("bar", _context->getRpathList()[1]);
+  EXPECT_EQ(2, _ctx->getRpathList().size());
+  EXPECT_EQ("foo", _ctx->getRpathList()[0]);
+  EXPECT_EQ("bar", _ctx->getRpathList()[1]);
 }
 
 TEST_F(GnuLdParserTest, RpathEq) {
   EXPECT_TRUE(parse("ld", "a.o", "-rpath=foo", nullptr));
-  EXPECT_EQ(1, _context->getRpathList().size());
-  EXPECT_EQ("foo", _context->getRpathList()[0]);
+  EXPECT_EQ(1, _ctx->getRpathList().size());
+  EXPECT_EQ("foo", _ctx->getRpathList()[0]);
 }
 
 // --defsym
 
 TEST_F(GnuLdParserTest, DefsymDecimal) {
   EXPECT_TRUE(parse("ld", "a.o", "--defsym=sym=1000", nullptr));
-  assert(_context.get());
-  auto map = _context->getAbsoluteSymbols();
+  assert(_ctx.get());
+  auto map = _ctx->getAbsoluteSymbols();
   EXPECT_EQ((size_t)1, map.size());
   EXPECT_EQ((uint64_t)1000, map["sym"]);
 }
 
 TEST_F(GnuLdParserTest, DefsymHexadecimal) {
   EXPECT_TRUE(parse("ld", "a.o", "--defsym=sym=0x1000", nullptr));
-  auto map = _context->getAbsoluteSymbols();
+  auto map = _ctx->getAbsoluteSymbols();
   EXPECT_EQ((size_t)1, map.size());
   EXPECT_EQ((uint64_t)0x1000, map["sym"]);
 }
 
 TEST_F(GnuLdParserTest, DefsymAlias) {
   EXPECT_TRUE(parse("ld", "a.o", "--defsym=sym=abc", nullptr));
-  auto map = _context->getAliases();
+  auto map = _ctx->getAliases();
   EXPECT_EQ((size_t)1, map.size());
   EXPECT_EQ("abc", map["sym"]);
 }
 
 TEST_F(GnuLdParserTest, DefsymOctal) {
   EXPECT_TRUE(parse("ld", "a.o", "--defsym=sym=0777", nullptr));
-  auto map = _context->getAbsoluteSymbols();
+  auto map = _ctx->getAbsoluteSymbols();
   EXPECT_EQ((size_t)1, map.size());
   EXPECT_EQ((uint64_t)0777, map["sym"]);
 }
@@ -191,7 +191,7 @@ TEST_F(GnuLdParserTest, DefsymMisssingValue) {
 TEST_F(GnuLdParserTest, AsNeeded) {
   EXPECT_TRUE(parse("ld", "a.o", "--as-needed", "b.o", "c.o",
                     "--no-as-needed", "d.o", nullptr));
-  std::vector<std::unique_ptr<Node>> &nodes = _context->getNodes();
+  std::vector<std::unique_ptr<Node>> &nodes = _ctx->getNodes();
   EXPECT_EQ((size_t)4, nodes.size());
   EXPECT_FALSE(cast<FileNode>(nodes[0].get())->asNeeded());
   EXPECT_TRUE(cast<FileNode>(nodes[1].get())->asNeeded());