Put PUBLIC lines in Mac and Linux symbol files

src/common/stabs_to_module_unittest.cc

 // Copyright (c) 2010 Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 56 matching lines @@
   EXPECT_EQ(0x10U, function->size);
   EXPECT_EQ(0U, function->parameter_size);
   ASSERT_EQ((size_t) 1, function->lines.size());
   Module::Line *line = &function->lines[0];
   EXPECT_EQ(0xfde4abbed390c394LL, line->address);
   EXPECT_EQ(0x10U, line->size); // derived from EndFunction
   EXPECT_TRUE(line->file == file);
   EXPECT_EQ(174823314, line->number);
 }
 
+TEST(StabsToModule, Externs) {
+  Module m("name", "os", "arch", "id");
+  StabsToModule h(&m);
+
+  // Feed in a few Extern symbols.
+  EXPECT_TRUE(h.Extern("_foo", 0xffff));
+  EXPECT_TRUE(h.Extern("__Z21dyldGlobalLockAcquirev", 0xaaaa));

[jimb, 2011/03/02 22:08:00]

Isn't this the first dependency on mangling syntax in the test suite? I don't
think we can really test that portably.

[Ted Mielczarek, 2011/03/03 18:36:49]

You are correct. I did want to test that, since it's something we do, but I
could make that #ifdef an appropriate GCC version if that would make you feel
better. (There's not a preprocessor symbol that indicates that the compiler is
using this particular C++ ABI, is there?)

[Ted Mielczarek, 2011/03/03 19:37:12]

Oh, no, actually, your existing tests have function name demangling tests:
http://code.google.com/p/google-breakpad/source/browse/trunk/src/common/stabs...

So this isn't any worse than what we already have.

+  h.Finalize();
+
+  // Now check to see what has been added to the Module.
+  vector<Module::Extern *> externs;
+  m.GetExterns(&externs, externs.end());
+  ASSERT_EQ((size_t) 2, externs.size());
+  Module::Extern *extern1 = externs[0];
+  EXPECT_STREQ("dyldGlobalLockAcquire()", extern1->name.c_str());
+  EXPECT_EQ((Module::Address)0xaaaa, extern1->address);
+  Module::Extern *extern2 = externs[1];
+  EXPECT_STREQ("foo", extern2->name.c_str());
+  EXPECT_EQ((Module::Address)0xffff, extern2->address);
+}
+
 TEST(StabsToModule, DuplicateFunctionNames) {
   Module m("name", "os", "arch", "id");
   StabsToModule h(&m);
 
   // Compilation unit with one function, mangled name.
   EXPECT_TRUE(h.StartCompilationUnit("compilation-unit", 0xf2cfda36ecf7f46cLL,
                                      "build-directory"));
   EXPECT_TRUE(h.StartFunction("funcfoo",
                               0xf2cfda36ecf7f46dLL));
   EXPECT_TRUE(h.EndFunction(0));
@@ skipping 129 matching lines @@
 // fallback size is something plausible
 
 // function size from function end
 // function size from next function start
 // function size from cu end
 // function size from next cu start
 // fallback size is something plausible
 
 // omitting functions outside the compilation unit's address range
 // zero-line, one-line, many-line functions