The Tor Browser / file comparison
comparison: toolkit/crashreporter/google-breakpad/src/common/stabs_reader_unittest.cc
toolkit/crashreporter/google-breakpad/src/common/stabs_reader_unittest.cc
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:09a3c716007d |
|---|---|
| 1 // Copyright (c) 2010 Google Inc. | |
| 2 // All rights reserved. | |
| 3 // | |
| 4 // Redistribution and use in source and binary forms, with or without | |
| 5 // modification, are permitted provided that the following conditions are | |
| 6 // met: | |
| 7 // | |
| 8 // * Redistributions of source code must retain the above copyright | |
| 9 // notice, this list of conditions and the following disclaimer. | |
| 10 // * Redistributions in binary form must reproduce the above | |
| 11 // copyright notice, this list of conditions and the following disclaimer | |
| 12 // in the documentation and/or other materials provided with the | |
| 13 // distribution. | |
| 14 // * Neither the name of Google Inc. nor the names of its | |
| 15 // contributors may be used to endorse or promote products derived from | |
| 16 // this software without specific prior written permission. | |
| 17 // | |
| 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 29 | |
| 30 // Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com> | |
| 31 | |
| 32 // stabs_reader_unittest.cc: Unit tests for google_breakpad::StabsReader. | |
| 33 | |
| 34 #include <assert.h> | |
| 35 #include <errno.h> | |
| 36 #include <stab.h> | |
| 37 #include <stdarg.h> | |
| 38 #include <stdlib.h> | |
| 39 #include <string.h> | |
| 40 | |
| 41 #include <fstream> | |
| 42 #include <iomanip> | |
| 43 #include <iostream> | |
| 44 #include <map> | |
| 45 #include <sstream> | |
| 46 #include <string> | |
| 47 | |
| 48 #include "breakpad_googletest_includes.h" | |
| 49 #include "common/stabs_reader.h" | |
| 50 #include "common/test_assembler.h" | |
| 51 #include "common/using_std_string.h" | |
| 52 | |
| 53 using ::testing::Eq; | |
| 54 using ::testing::InSequence; | |
| 55 using ::testing::Return; | |
| 56 using ::testing::StrEq; | |
| 57 using ::testing::Test; | |
| 58 using ::testing::_; | |
| 59 using google_breakpad::StabsHandler; | |
| 60 using google_breakpad::StabsReader; | |
| 61 using google_breakpad::test_assembler::Label; | |
| 62 using google_breakpad::test_assembler::Section; | |
| 63 using google_breakpad::test_assembler::kBigEndian; | |
| 64 using google_breakpad::test_assembler::kLittleEndian; | |
| 65 using std::map; | |
| 66 | |
| 67 namespace { | |
| 68 | |
| 69 // A StringAssembler is a class for generating .stabstr sections to present | |
| 70 // as input to the STABS parser. | |
| 71 class StringAssembler: public Section { | |
| 72 public: | |
| 73 StringAssembler() : in_cu_(false) { StartCU(); } | |
| 74 | |
| 75 // Add the string S to this StringAssembler, and return the string's | |
| 76 // offset within this compilation unit's strings. If S has been added | |
| 77 // already, this returns the offset of its first instance. | |
| 78 size_t Add(const string &s) { | |
| 79 map<string, size_t>::iterator it = added_.find(s); | |
| 80 if (it != added_.end()) | |
| 81 return it->second; | |
| 82 size_t offset = Size() - cu_start_; | |
| 83 AppendCString(s); | |
| 84 added_[s] = offset; | |
| 85 return offset; | |
| 86 } | |
| 87 | |
| 88 // Start a fresh compilation unit string collection. | |
| 89 void StartCU() { | |
| 90 // Ignore duplicate calls to StartCU. Our test data don't always call | |
| 91 // StartCU at all, meaning that our constructor has to take care of it, | |
| 92 // meaning that tests that *do* call StartCU call it twice at the | |
| 93 // beginning. This is not worth smoothing out. | |
| 94 if (in_cu_) return; | |
| 95 | |
| 96 added_.clear(); | |
| 97 cu_start_ = Size(); | |
| 98 | |
| 99 // Each compilation unit's strings start with an empty string. | |
| 100 AppendCString(""); | |
| 101 added_[""] = 0; | |
| 102 | |
| 103 in_cu_ = true; | |
| 104 } | |
| 105 | |
| 106 // Finish off the current CU's strings. | |
| 107 size_t EndCU() { | |
| 108 assert(in_cu_); | |
| 109 in_cu_ = false; | |
| 110 return Size() - cu_start_; | |
| 111 } | |
| 112 | |
| 113 private: | |
| 114 // The offset of the start of this compilation unit's strings. | |
| 115 size_t cu_start_; | |
| 116 | |
| 117 // True if we're in a CU. | |
| 118 bool in_cu_; | |
| 119 | |
| 120 // A map from the strings that have been added to this section to | |
| 121 // their starting indices within their compilation unit. | |
| 122 map<string, size_t> added_; | |
| 123 }; | |
| 124 | |
| 125 // A StabsAssembler is a class for generating .stab sections to present as | |
| 126 // test input for the STABS parser. | |
| 127 class StabsAssembler: public Section { | |
| 128 public: | |
| 129 // Create a StabsAssembler that uses StringAssembler for its strings. | |
| 130 StabsAssembler(StringAssembler *string_assembler) | |
| 131 : Section(string_assembler->endianness()), | |
| 132 string_assembler_(string_assembler), | |
| 133 value_size_(0), | |
| 134 entry_count_(0), | |
| 135 cu_header_(NULL) { } | |
| 136 ~StabsAssembler() { assert(!cu_header_); } | |
| 137 | |
| 138 // Accessor and setter for value_size_. | |
| 139 size_t value_size() const { return value_size_; } | |
| 140 StabsAssembler &set_value_size(size_t value_size) { | |
| 141 value_size_ = value_size; | |
| 142 return *this; | |
| 143 } | |
| 144 | |
| 145 // Append a STAB entry to the end of this section with the given | |
| 146 // characteristics. NAME is the offset of this entry's name string within | |
| 147 // its compilation unit's portion of the .stabstr section; this can be a | |
| 148 // value generated by a StringAssembler. Return a reference to this | |
| 149 // StabsAssembler. | |
| 150 StabsAssembler &Stab(uint8_t type, uint8_t other, Label descriptor, | |
| 151 Label value, Label name) { | |
| 152 D32(name); | |
| 153 D8(type); | |
| 154 D8(other); | |
| 155 D16(descriptor); | |
| 156 Append(endianness(), value_size_, value); | |
| 157 entry_count_++; | |
| 158 return *this; | |
| 159 } | |
| 160 | |
| 161 // As above, but automatically add NAME to our StringAssembler. | |
| 162 StabsAssembler &Stab(uint8_t type, uint8_t other, Label descriptor, | |
| 163 Label value, const string &name) { | |
| 164 return Stab(type, other, descriptor, value, string_assembler_->Add(name)); | |
| 165 } | |
| 166 | |
| 167 // Start a compilation unit named NAME, with an N_UNDF symbol to start | |
| 168 // it, and its own portion of the string section. Return a reference to | |
| 169 // this StabsAssembler. | |
| 170 StabsAssembler &StartCU(const string &name) { | |
| 171 assert(!cu_header_); | |
| 172 cu_header_ = new CUHeader; | |
| 173 string_assembler_->StartCU(); | |
| 174 entry_count_ = 0; | |
| 175 return Stab(N_UNDF, 0, | |
| 176 cu_header_->final_entry_count, | |
| 177 cu_header_->final_string_size, | |
| 178 string_assembler_->Add(name)); | |
| 179 } | |
| 180 | |
| 181 // Close off the current compilation unit. Return a reference to this | |
| 182 // StabsAssembler. | |
| 183 StabsAssembler &EndCU() { | |
| 184 assert(cu_header_); | |
| 185 cu_header_->final_entry_count = entry_count_; | |
| 186 cu_header_->final_string_size = string_assembler_->EndCU(); | |
| 187 delete cu_header_; | |
| 188 cu_header_ = NULL; | |
| 189 return *this; | |
| 190 } | |
| 191 | |
| 192 private: | |
| 193 // Data used in a compilation unit header STAB that we won't know until | |
| 194 // we've finished the compilation unit. | |
| 195 struct CUHeader { | |
| 196 // The final number of entries this compilation unit will hold. | |
| 197 Label final_entry_count; | |
| 198 | |
| 199 // The final size of this compilation unit's strings. | |
| 200 Label final_string_size; | |
| 201 }; | |
| 202 | |
| 203 // The strings for our STABS entries. | |
| 204 StringAssembler *string_assembler_; | |
| 205 | |
| 206 // The size of the 'value' field of stabs entries in this section. | |
| 207 size_t value_size_; | |
| 208 | |
| 209 // The number of entries in this compilation unit so far. | |
| 210 size_t entry_count_; | |
| 211 | |
| 212 // Header labels for this compilation unit, if we've started one but not | |
| 213 // finished it. | |
| 214 CUHeader *cu_header_; | |
| 215 }; | |
| 216 | |
| 217 class MockStabsReaderHandler: public StabsHandler { | |
| 218 public: | |
| 219 MOCK_METHOD3(StartCompilationUnit, | |
| 220 bool(const char *, uint64_t, const char *)); | |
| 221 MOCK_METHOD1(EndCompilationUnit, bool(uint64_t)); | |
| 222 MOCK_METHOD2(StartFunction, bool(const string &, uint64_t)); | |
| 223 MOCK_METHOD1(EndFunction, bool(uint64_t)); | |
| 224 MOCK_METHOD3(Line, bool(uint64_t, const char *, int)); | |
| 225 MOCK_METHOD2(Extern, bool(const string &, uint64_t)); | |
| 226 void Warning(const char *format, ...) { MockWarning(format); } | |
| 227 MOCK_METHOD1(MockWarning, void(const char *)); | |
| 228 }; | |
| 229 | |
| 230 struct StabsFixture { | |
| 231 StabsFixture() : stabs(&strings), unitized(true) { } | |
| 232 | |
| 233 // Create a StabsReader to parse the mock stabs data in stabs and | |
| 234 // strings, and pass the parsed information to mock_handler. Use the | |
| 235 // endianness and value size of stabs to parse the data. If all goes | |
| 236 // well, return the result of calling the reader's Process member | |
| 237 // function. Otherwise, return false. | |
| 238 bool ApplyHandlerToMockStabsData() { | |
| 239 string stabs_contents, stabstr_contents; | |
| 240 if (!stabs.GetContents(&stabs_contents) || | |
| 241 !strings.GetContents(&stabstr_contents)) | |
| 242 return false; | |
| 243 | |
| 244 // Run the parser on the test input, passing whatever we find to HANDLER. | |
| 245 StabsReader reader( | |
| 246 reinterpret_cast<const uint8_t *>(stabs_contents.data()), | |
| 247 stabs_contents.size(), | |
| 248 reinterpret_cast<const uint8_t *>(stabstr_contents.data()), | |
| 249 stabstr_contents.size(), | |
| 250 stabs.endianness() == kBigEndian, stabs.value_size(), unitized, | |
| 251 &mock_handler); | |
| 252 return reader.Process(); | |
| 253 } | |
| 254 | |
| 255 StringAssembler strings; | |
| 256 StabsAssembler stabs; | |
| 257 bool unitized; | |
| 258 MockStabsReaderHandler mock_handler; | |
| 259 }; | |
| 260 | |
| 261 class Stabs: public StabsFixture, public Test { }; | |
| 262 | |
| 263 TEST_F(Stabs, MockStabsInput) { | |
| 264 stabs.set_endianness(kLittleEndian); | |
| 265 stabs.set_value_size(4); | |
| 266 stabs | |
| 267 .Stab(N_SO, 149, 40232, 0x18a2a72bU, "builddir/") | |
| 268 .Stab(N_FUN, 83, 50010, 0x91a5353fU, | |
| 269 "not the SO with source file name we expected ") | |
| 270 .Stab(N_SO, 165, 24791, 0xfe69d23cU, "") | |
| 271 .Stab(N_SO, 184, 34178, 0xca4d883aU, "builddir1/") | |
| 272 .Stab(N_SO, 83, 40859, 0xd2fe5df3U, "file1.c") | |
| 273 .Stab(N_LSYM, 147, 39565, 0x60d4bb8aU, "not the FUN we're looking for") | |
| 274 .Stab(N_FUN, 120, 50271, 0xa049f4b1U, "fun1") | |
| 275 .Stab(N_BINCL, 150, 15694, 0xef65c659U, | |
| 276 "something to ignore in a FUN body") | |
| 277 .Stab(N_SLINE, 147, 4967, 0xd904b3f, "") | |
| 278 .Stab(N_SOL, 177, 56135, 0xbd97b1dcU, "header.h") | |
| 279 .Stab(N_SLINE, 130, 24610, 0x90f145b, "") | |
| 280 .Stab(N_FUN, 45, 32441, 0xbf27cf93U, | |
| 281 "fun2:some stabs type info here:to trim from the name") | |
| 282 .Stab(N_SLINE, 138, 39002, 0x8148b87, "") | |
| 283 .Stab(N_SOL, 60, 49318, 0x1d06e025U, "file1.c") | |
| 284 .Stab(N_SLINE, 29, 52163, 0x6eebbb7, "") | |
| 285 .Stab(N_SO, 167, 4647, 0xd04b7448U, "") | |
| 286 .Stab(N_LSYM, 58, 37837, 0xe6b14d37U, "") | |
| 287 .Stab(N_SO, 152, 7810, 0x11759f10U, "file3.c") | |
| 288 .Stab(N_SO, 218, 12447, 0x11cfe4b5U, ""); | |
| 289 | |
| 290 { | |
| 291 InSequence s; | |
| 292 | |
| 293 EXPECT_CALL(mock_handler, | |
| 294 StartCompilationUnit(StrEq("file1.c"), 0xd2fe5df3U, | |
| 295 StrEq("builddir1/"))) | |
| 296 .WillOnce(Return(true)); | |
| 297 EXPECT_CALL(mock_handler, StartFunction(StrEq("fun1"), 0xa049f4b1U)) | |
| 298 .WillOnce(Return(true)); | |
| 299 EXPECT_CALL(mock_handler, | |
| 300 Line(0xa049f4b1U + 0xd904b3f, StrEq("file1.c"), 4967)) | |
| 301 .WillOnce(Return(true)); | |
| 302 EXPECT_CALL(mock_handler, | |
| 303 Line(0xa049f4b1U + 0x90f145b, StrEq("header.h"), 24610)) | |
| 304 .WillOnce(Return(true)); | |
| 305 EXPECT_CALL(mock_handler, EndFunction(0xbf27cf93U)) | |
| 306 .WillOnce(Return(true)); | |
| 307 EXPECT_CALL(mock_handler, StartFunction(StrEq("fun2"), 0xbf27cf93U)) | |
| 308 .WillOnce(Return(true)); | |
| 309 EXPECT_CALL(mock_handler, | |
| 310 Line(0xbf27cf93U + 0x8148b87, StrEq("header.h"), 39002)) | |
| 311 .WillOnce(Return(true)); | |
| 312 EXPECT_CALL(mock_handler, | |
| 313 Line(0xbf27cf93U + 0x6eebbb7, StrEq("file1.c"), 52163)) | |
| 314 .WillOnce(Return(true)); | |
| 315 EXPECT_CALL(mock_handler, EndFunction(0xd04b7448U)) | |
| 316 .WillOnce(Return(true)); | |
| 317 EXPECT_CALL(mock_handler, EndCompilationUnit(0xd04b7448U)) | |
| 318 .WillOnce(Return(true)); | |
| 319 EXPECT_CALL(mock_handler, StartCompilationUnit(StrEq("file3.c"), | |
| 320 0x11759f10U, NULL)) | |
| 321 .WillOnce(Return(true)); | |
| 322 EXPECT_CALL(mock_handler, EndCompilationUnit(0x11cfe4b5U)) | |
| 323 .WillOnce(Return(true)); | |
| 324 } | |
| 325 | |
| 326 ASSERT_TRUE(ApplyHandlerToMockStabsData()); | |
| 327 } | |
| 328 | |
| 329 TEST_F(Stabs, AbruptCU) { | |
| 330 stabs.set_endianness(kBigEndian); | |
| 331 stabs.set_value_size(4); | |
| 332 stabs.Stab(N_SO, 177, 23446, 0xbf10d5e4, "file2-1.c"); | |
| 333 | |
| 334 { | |
| 335 InSequence s; | |
| 336 | |
| 337 EXPECT_CALL(mock_handler, | |
| 338 StartCompilationUnit(StrEq("file2-1.c"), 0xbf10d5e4, NULL)) | |
| 339 .WillOnce(Return(true)); | |
| 340 EXPECT_CALL(mock_handler, EndCompilationUnit(0)) | |
| 341 .WillOnce(Return(true)); | |
| 342 } | |
| 343 | |
| 344 ASSERT_TRUE(ApplyHandlerToMockStabsData()); | |
| 345 } | |
| 346 | |
| 347 TEST_F(Stabs, AbruptFunction) { | |
| 348 stabs.set_endianness(kLittleEndian); | |
| 349 stabs.set_value_size(8); | |
| 350 stabs | |
| 351 .Stab(N_SO, 218, 26631, 0xb83ddf10U, "file3-1.c") | |
| 352 .Stab(N_FUN, 113, 24765, 0xbbd4a145U, "fun3_1"); | |
| 353 | |
| 354 { | |
| 355 InSequence s; | |
| 356 | |
| 357 EXPECT_CALL(mock_handler, | |
| 358 StartCompilationUnit(StrEq("file3-1.c"), 0xb83ddf10U, NULL)) | |
| 359 .WillOnce(Return(true)); | |
| 360 EXPECT_CALL(mock_handler, StartFunction(StrEq("fun3_1"), 0xbbd4a145U)) | |
| 361 .WillOnce(Return(true)); | |
| 362 EXPECT_CALL(mock_handler, EndFunction(0)) | |
| 363 .WillOnce(Return(true)); | |
| 364 EXPECT_CALL(mock_handler, EndCompilationUnit(0)) | |
| 365 .WillOnce(Return(true)); | |
| 366 } | |
| 367 | |
| 368 ASSERT_TRUE(ApplyHandlerToMockStabsData()); | |
| 369 } | |
| 370 | |
| 371 TEST_F(Stabs, NoCU) { | |
| 372 stabs.set_endianness(kBigEndian); | |
| 373 stabs.set_value_size(8); | |
| 374 stabs.Stab(N_SO, 161, 25673, 0x8f676e7bU, "build-directory/"); | |
| 375 | |
| 376 EXPECT_CALL(mock_handler, StartCompilationUnit(_, _, _)) | |
| 377 .Times(0); | |
| 378 EXPECT_CALL(mock_handler, StartFunction(_, _)) | |
| 379 .Times(0); | |
| 380 | |
| 381 ASSERT_TRUE(ApplyHandlerToMockStabsData()); | |
| 382 } | |
| 383 | |
| 384 TEST_F(Stabs, NoCUEnd) { | |
| 385 stabs.set_endianness(kBigEndian); | |
| 386 stabs.set_value_size(8); | |
| 387 stabs | |
| 388 .Stab(N_SO, 116, 58280, 0x2f7493c9U, "file5-1.c") | |
| 389 .Stab(N_SO, 224, 23057, 0xf9f1d50fU, "file5-2.c"); | |
| 390 | |
| 391 { | |
| 392 InSequence s; | |
| 393 | |
| 394 EXPECT_CALL(mock_handler, | |
| 395 StartCompilationUnit(StrEq("file5-1.c"), 0x2f7493c9U, NULL)) | |
| 396 .WillOnce(Return(true)); | |
| 397 EXPECT_CALL(mock_handler, EndCompilationUnit(0)) | |
| 398 .WillOnce(Return(true)); | |
| 399 EXPECT_CALL(mock_handler, | |
| 400 StartCompilationUnit(StrEq("file5-2.c"), 0xf9f1d50fU, NULL)) | |
| 401 .WillOnce(Return(true)); | |
| 402 EXPECT_CALL(mock_handler, EndCompilationUnit(0)) | |
| 403 .WillOnce(Return(true)); | |
| 404 } | |
| 405 | |
| 406 ASSERT_TRUE(ApplyHandlerToMockStabsData()); | |
| 407 } | |
| 408 | |
| 409 // On systems that store STABS in sections, string offsets are relative to | |
| 410 // the beginning of that compilation unit's strings, marked with N_UNDF | |
| 411 // symbols; see the comments for StabsReader::StabsReader. | |
| 412 TEST_F(Stabs, Unitized) { | |
| 413 stabs.set_endianness(kBigEndian); | |
| 414 stabs.set_value_size(4); | |
| 415 stabs | |
| 416 .StartCU("antimony") | |
| 417 .Stab(N_SO, 49, 26043, 0x7e259f1aU, "antimony") | |
| 418 .Stab(N_FUN, 101, 63253, 0x7fbcccaeU, "arsenic") | |
| 419 .Stab(N_SO, 124, 37175, 0x80b0014cU, "") | |
| 420 .EndCU() | |
| 421 .StartCU("aluminum") | |
| 422 .Stab(N_SO, 72, 23084, 0x86756839U, "aluminum") | |
| 423 .Stab(N_FUN, 59, 3305, 0xa8e120b0U, "selenium") | |
| 424 .Stab(N_SO, 178, 56949, 0xbffff983U, "") | |
| 425 .EndCU(); | |
| 426 | |
| 427 { | |
| 428 InSequence s; | |
| 429 EXPECT_CALL(mock_handler, | |
| 430 StartCompilationUnit(StrEq("antimony"), 0x7e259f1aU, NULL)) | |
| 431 .WillOnce(Return(true)); | |
| 432 EXPECT_CALL(mock_handler, StartFunction(Eq("arsenic"), 0x7fbcccaeU)) | |
| 433 .WillOnce(Return(true)); | |
| 434 EXPECT_CALL(mock_handler, EndFunction(0x80b0014cU)) | |
| 435 .WillOnce(Return(true)); | |
| 436 EXPECT_CALL(mock_handler, EndCompilationUnit(0x80b0014cU)) | |
| 437 .WillOnce(Return(true)); | |
| 438 EXPECT_CALL(mock_handler, | |
| 439 StartCompilationUnit(StrEq("aluminum"), 0x86756839U, NULL)) | |
| 440 .WillOnce(Return(true)); | |
| 441 EXPECT_CALL(mock_handler, StartFunction(Eq("selenium"), 0xa8e120b0U)) | |
| 442 .WillOnce(Return(true)); | |
| 443 EXPECT_CALL(mock_handler, EndFunction(0xbffff983U)) | |
| 444 .WillOnce(Return(true)); | |
| 445 EXPECT_CALL(mock_handler, EndCompilationUnit(0xbffff983U)) | |
| 446 .WillOnce(Return(true)); | |
| 447 } | |
| 448 | |
| 449 ASSERT_TRUE(ApplyHandlerToMockStabsData()); | |
| 450 } | |
| 451 | |
| 452 // On systems that store STABS entries in the real symbol table, the N_UNDF | |
| 453 // entries have no special meaning, and shouldn't mess up the string | |
| 454 // indices. | |
| 455 TEST_F(Stabs, NonUnitized) { | |
| 456 stabs.set_endianness(kLittleEndian); | |
| 457 stabs.set_value_size(4); | |
| 458 unitized = false; | |
| 459 stabs | |
| 460 .Stab(N_UNDF, 21, 11551, 0x9bad2b2e, "") | |
| 461 .Stab(N_UNDF, 21, 11551, 0x9bad2b2e, "") | |
| 462 .Stab(N_SO, 71, 45139, 0x11a97352, "Tanzania") | |
| 463 .Stab(N_SO, 221, 41976, 0x21a97352, ""); | |
| 464 | |
| 465 { | |
| 466 InSequence s; | |
| 467 EXPECT_CALL(mock_handler, | |
| 468 StartCompilationUnit(StrEq("Tanzania"), | |
| 469 0x11a97352, NULL)) | |
| 470 .WillOnce(Return(true)); | |
| 471 EXPECT_CALL(mock_handler, EndCompilationUnit(0x21a97352)) | |
| 472 .WillOnce(Return(true)); | |
| 473 } | |
| 474 | |
| 475 ASSERT_TRUE(ApplyHandlerToMockStabsData()); | |
| 476 } | |
| 477 | |
| 478 TEST_F(Stabs, FunctionEnd) { | |
| 479 stabs.set_endianness(kLittleEndian); | |
| 480 stabs.set_value_size(8); | |
| 481 stabs | |
| 482 .Stab(N_SO, 102, 62362, 0x52a830d644cd6942ULL, "compilation unit") | |
| 483 // This function is terminated by the start of the next function. | |
| 484 .Stab(N_FUN, 216, 38405, 0xbb5ab70ecdd23bfeULL, "function 1") | |
| 485 // This function is terminated by an explicit end-of-function stab, | |
| 486 // whose value is a size in bytes. | |
| 487 .Stab(N_FUN, 240, 10973, 0xc954de9b8fb3e5e2ULL, "function 2") | |
| 488 .Stab(N_FUN, 14, 36749, 0xc1ab, "") | |
| 489 // This function is terminated by the end of the compilation unit. | |
| 490 .Stab(N_FUN, 143, 64514, 0xdff98c9a35386e1fULL, "function 3") | |
| 491 .Stab(N_SO, 164, 60142, 0xfdacb856e78bbf57ULL, ""); | |
| 492 | |
| 493 { | |
| 494 InSequence s; | |
| 495 EXPECT_CALL(mock_handler, | |
| 496 StartCompilationUnit(StrEq("compilation unit"), | |
| 497 0x52a830d644cd6942ULL, NULL)) | |
| 498 .WillOnce(Return(true)); | |
| 499 EXPECT_CALL(mock_handler, | |
| 500 StartFunction(Eq("function 1"), 0xbb5ab70ecdd23bfeULL)) | |
| 501 .WillOnce(Return(true)); | |
| 502 EXPECT_CALL(mock_handler, EndFunction(0xc954de9b8fb3e5e2ULL)) | |
| 503 .WillOnce(Return(true)); | |
| 504 EXPECT_CALL(mock_handler, | |
| 505 StartFunction(Eq("function 2"), 0xc954de9b8fb3e5e2ULL)) | |
| 506 .WillOnce(Return(true)); | |
| 507 EXPECT_CALL(mock_handler, EndFunction(0xc954de9b8fb3e5e2ULL + 0xc1ab)) | |
| 508 .WillOnce(Return(true)); | |
| 509 EXPECT_CALL(mock_handler, | |
| 510 StartFunction(Eq("function 3"), 0xdff98c9a35386e1fULL)) | |
| 511 .WillOnce(Return(true)); | |
| 512 EXPECT_CALL(mock_handler, EndFunction(0xfdacb856e78bbf57ULL)) | |
| 513 .WillOnce(Return(true)); | |
| 514 EXPECT_CALL(mock_handler, EndCompilationUnit(0xfdacb856e78bbf57ULL)) | |
| 515 .WillOnce(Return(true)); | |
| 516 } | |
| 517 | |
| 518 ASSERT_TRUE(ApplyHandlerToMockStabsData()); | |
| 519 } | |
| 520 | |
| 521 // On Mac OS X, SLINE records can appear before the FUN stab to which they | |
| 522 // belong, and their values are absolute addresses, not offsets. | |
| 523 TEST_F(Stabs, LeadingLine) { | |
| 524 stabs.set_endianness(kBigEndian); | |
| 525 stabs.set_value_size(4); | |
| 526 stabs | |
| 527 .Stab(N_SO, 179, 27357, 0x8adabc15, "build directory/") | |
| 528 .Stab(N_SO, 52, 53058, 0x4c7e3bf4, "compilation unit") | |
| 529 .Stab(N_SOL, 165, 12086, 0x6a797ca3, "source file name") | |
| 530 .Stab(N_SLINE, 229, 20015, 0x4cb3d7e0, "") | |
| 531 .Stab(N_SLINE, 89, 43802, 0x4cba8b88, "") | |
| 532 .Stab(N_FUN, 251, 51639, 0xce1b98fa, "rutabaga") | |
| 533 .Stab(N_FUN, 218, 16113, 0x5798, "") | |
| 534 .Stab(N_SO, 52, 53058, 0xd4af4415, ""); | |
| 535 | |
| 536 { | |
| 537 InSequence s; | |
| 538 EXPECT_CALL(mock_handler, | |
| 539 StartCompilationUnit(StrEq("compilation unit"), | |
| 540 0x4c7e3bf4, StrEq("build directory/"))) | |
| 541 .WillOnce(Return(true)); | |
| 542 EXPECT_CALL(mock_handler, | |
| 543 StartFunction(Eq("rutabaga"), 0xce1b98fa)) | |
| 544 .WillOnce(Return(true)); | |
| 545 EXPECT_CALL(mock_handler, | |
| 546 Line(0x4cb3d7e0, StrEq("source file name"), 20015)) | |
| 547 .WillOnce(Return(true)); | |
| 548 EXPECT_CALL(mock_handler, | |
| 549 Line(0x4cba8b88, StrEq("source file name"), 43802)) | |
| 550 .WillOnce(Return(true)); | |
| 551 EXPECT_CALL(mock_handler, EndFunction(0xce1b98fa + 0x5798)) | |
| 552 .WillOnce(Return(true)); | |
| 553 EXPECT_CALL(mock_handler, EndCompilationUnit(0xd4af4415)) | |
| 554 .WillOnce(Return(true)); | |
| 555 } | |
| 556 | |
| 557 ASSERT_TRUE(ApplyHandlerToMockStabsData()); | |
| 558 } | |
| 559 | |
| 560 | |
| 561 #if defined(HAVE_MACH_O_NLIST_H) | |
| 562 // These tests have no meaning on non-Mach-O-based systems, as | |
| 563 // only Mach-O uses N_SECT to represent public symbols. | |
| 564 TEST_F(Stabs, OnePublicSymbol) { | |
| 565 stabs.set_endianness(kLittleEndian); | |
| 566 stabs.set_value_size(4); | |
| 567 | |
| 568 const uint32_t kExpectedAddress = 0x9000; | |
| 569 const string kExpectedFunctionName("public_function"); | |
| 570 stabs | |
| 571 .Stab(N_SECT, 1, 0, kExpectedAddress, kExpectedFunctionName); | |
| 572 | |
| 573 { | |
| 574 InSequence s; | |
| 575 EXPECT_CALL(mock_handler, | |
| 576 Extern(StrEq(kExpectedFunctionName), | |
| 577 kExpectedAddress)) | |
| 578 .WillOnce(Return(true)); | |
| 579 } | |
| 580 ASSERT_TRUE(ApplyHandlerToMockStabsData()); | |
| 581 } | |
| 582 | |
| 583 TEST_F(Stabs, TwoPublicSymbols) { | |
| 584 stabs.set_endianness(kLittleEndian); | |
| 585 stabs.set_value_size(4); | |
| 586 | |
| 587 const uint32_t kExpectedAddress1 = 0xB0B0B0B0; | |
| 588 const string kExpectedFunctionName1("public_function"); | |
| 589 const uint32_t kExpectedAddress2 = 0xF0F0F0F0; | |
| 590 const string kExpectedFunctionName2("something else"); | |
| 591 stabs | |
| 592 .Stab(N_SECT, 1, 0, kExpectedAddress1, kExpectedFunctionName1) | |
| 593 .Stab(N_SECT, 1, 0, kExpectedAddress2, kExpectedFunctionName2); | |
| 594 | |
| 595 { | |
| 596 InSequence s; | |
| 597 EXPECT_CALL(mock_handler, | |
| 598 Extern(StrEq(kExpectedFunctionName1), | |
| 599 kExpectedAddress1)) | |
| 600 .WillOnce(Return(true)); | |
| 601 EXPECT_CALL(mock_handler, | |
| 602 Extern(StrEq(kExpectedFunctionName2), | |
| 603 kExpectedAddress2)) | |
| 604 .WillOnce(Return(true)); | |
| 605 } | |
| 606 ASSERT_TRUE(ApplyHandlerToMockStabsData()); | |
| 607 } | |
| 608 | |
| 609 #endif | |
| 610 | |
| 611 } // anonymous namespace |
