unittests/MachOTests/MachONormalizedFileYAMLTests.cpp

   1 //===- lld/unittest/MachOTests/MachONormalizedFileYAMLTests.cpp -----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "gtest/gtest.h"
  11 #include "../../lib/ReaderWriter/MachO/MachONormalizedFile.h"
  12 #include "llvm/Support/MachO.h"
  13 #include <assert.h>
  14 #include <vector>
  15
  16 using llvm::StringRef;
  17 using llvm::MemoryBuffer;
  18 using llvm::ErrorOr;
  19 using lld::mach_o::normalized::NormalizedFile;
  20 using lld::mach_o::normalized::Symbol;
  21 using lld::mach_o::normalized::Section;
  22 using lld::mach_o::normalized::Relocation;
  23
  24
  25 static std::unique_ptr<NormalizedFile> fromYAML(StringRef str) {
  26   std::unique_ptr<MemoryBuffer> mb(MemoryBuffer::getMemBuffer(str));
  27   ErrorOr<std::unique_ptr<NormalizedFile>> r
  28                                     = lld::mach_o::normalized::readYaml(mb);
  29   EXPECT_FALSE(!r);
  30   return std::move(*r);
  31 }
  32
  33 static void toYAML(const NormalizedFile &f, std::string &out) {
  34   llvm::raw_string_ostream ostr(out);
  35   std::error_code ec = lld::mach_o::normalized::writeYaml(f, ostr);
  36   EXPECT_TRUE(!ec);
  37 }
  38
  39
  40 // ppc is no longer supported, but it is here to test endianness handling.
  41 TEST(ObjectFileYAML, empty_ppc) {
  42   std::unique_ptr<NormalizedFile> f = fromYAML(
  43     "---\n"
  44     "arch:      ppc\n"
  45     "file-type: MH_OBJECT\n"
  46     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
  47     "...\n");
  48   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_ppc);
  49   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
  50   EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
  51   EXPECT_TRUE(f->sections.empty());
  52   EXPECT_TRUE(f->localSymbols.empty());
  53   EXPECT_TRUE(f->globalSymbols.empty());
  54   EXPECT_TRUE(f->undefinedSymbols.empty());
  55 }
  56
  57 TEST(ObjectFileYAML, empty_x86_64) {
  58   std::unique_ptr<NormalizedFile> f = fromYAML(
  59     "---\n"
  60     "arch:      x86_64\n"
  61     "file-type: MH_OBJECT\n"
  62     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
  63     "...\n");
  64   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
  65   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
  66   EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
  67   EXPECT_TRUE(f->sections.empty());
  68   EXPECT_TRUE(f->localSymbols.empty());
  69   EXPECT_TRUE(f->globalSymbols.empty());
  70   EXPECT_TRUE(f->undefinedSymbols.empty());
  71 }
  72
  73 TEST(ObjectFileYAML, empty_x86) {
  74   std::unique_ptr<NormalizedFile> f = fromYAML(
  75     "---\n"
  76     "arch:      x86\n"
  77     "file-type: MH_OBJECT\n"
  78     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
  79     "...\n");
  80   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86);
  81   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
  82   EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
  83   EXPECT_TRUE(f->sections.empty());
  84   EXPECT_TRUE(f->localSymbols.empty());
  85   EXPECT_TRUE(f->globalSymbols.empty());
  86   EXPECT_TRUE(f->undefinedSymbols.empty());
  87 }
  88
  89 TEST(ObjectFileYAML, empty_armv6) {
  90   std::unique_ptr<NormalizedFile> f = fromYAML(
  91     "---\n"
  92     "arch:      armv6\n"
  93     "file-type: MH_OBJECT\n"
  94     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
  95     "...\n");
  96   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv6);
  97   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
  98   EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
  99   EXPECT_TRUE(f->sections.empty());
 100   EXPECT_TRUE(f->localSymbols.empty());
 101   EXPECT_TRUE(f->globalSymbols.empty());
 102   EXPECT_TRUE(f->undefinedSymbols.empty());
 103 }
 104
 105 TEST(ObjectFileYAML, empty_armv7) {
 106   std::unique_ptr<NormalizedFile> f = fromYAML(
 107     "---\n"
 108     "arch:      armv7\n"
 109     "file-type: MH_OBJECT\n"
 110     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
 111     "...\n");
 112   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv7);
 113   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
 114   EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
 115   EXPECT_TRUE(f->sections.empty());
 116   EXPECT_TRUE(f->localSymbols.empty());
 117   EXPECT_TRUE(f->globalSymbols.empty());
 118   EXPECT_TRUE(f->undefinedSymbols.empty());
 119 }
 120
 121 TEST(ObjectFileYAML, empty_armv7s) {
 122   std::unique_ptr<NormalizedFile> f = fromYAML(
 123     "---\n"
 124     "arch:      armv7s\n"
 125     "file-type: MH_OBJECT\n"
 126     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
 127     "...\n");
 128   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv7s);
 129   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
 130   EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
 131   EXPECT_TRUE(f->sections.empty());
 132   EXPECT_TRUE(f->localSymbols.empty());
 133   EXPECT_TRUE(f->globalSymbols.empty());
 134   EXPECT_TRUE(f->undefinedSymbols.empty());
 135 }
 136
 137
 138 TEST(ObjectFileYAML, roundTrip) {
 139   std::string intermediate;
 140   {
 141     NormalizedFile f;
 142     f.arch = lld::MachOLinkingContext::arch_x86_64;
 143     f.fileType = llvm::MachO::MH_OBJECT;
 144     f.flags = llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS;
 145     f.os = lld::MachOLinkingContext::OS::macOSX;
 146     toYAML(f, intermediate);
 147   }
 148   {
 149     std::unique_ptr<NormalizedFile> f2 = fromYAML(intermediate);
 150     EXPECT_EQ(f2->arch, lld::MachOLinkingContext::arch_x86_64);
 151     EXPECT_EQ((int)(f2->fileType), llvm::MachO::MH_OBJECT);
 152     EXPECT_EQ((int)(f2->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
 153     EXPECT_TRUE(f2->sections.empty());
 154     EXPECT_TRUE(f2->localSymbols.empty());
 155     EXPECT_TRUE(f2->globalSymbols.empty());
 156     EXPECT_TRUE(f2->undefinedSymbols.empty());
 157   }
 158 }
 159
 160
 161 TEST(ObjectFileYAML, oneSymbol) {
 162   std::unique_ptr<NormalizedFile> f = fromYAML(
 163     "---\n"
 164     "arch:      x86_64\n"
 165     "file-type: MH_OBJECT\n"
 166     "global-symbols:\n"
 167     "  - name:   _main\n"
 168     "    type:   N_SECT\n"
 169     "    scope:  [ N_EXT ]\n"
 170     "    sect:   1\n"
 171     "    desc:   [ ]\n"
 172     "    value:  0x100\n"
 173     "...\n");
 174   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
 175   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
 176   EXPECT_TRUE(f->sections.empty());
 177   EXPECT_TRUE(f->localSymbols.empty());
 178   EXPECT_TRUE(f->undefinedSymbols.empty());
 179   EXPECT_EQ(f->globalSymbols.size(), 1UL);
 180   const Symbol& sym = f->globalSymbols[0];
 181   EXPECT_TRUE(sym.name.equals("_main"));
 182   EXPECT_EQ((int)(sym.type), llvm::MachO::N_SECT);
 183   EXPECT_EQ((int)(sym.scope), llvm::MachO::N_EXT);
 184   EXPECT_EQ(sym.sect, 1);
 185   EXPECT_EQ((int)(sym.desc), 0);
 186   EXPECT_EQ((uint64_t)sym.value, 0x100ULL);
 187 }
 188
 189
 190 TEST(ObjectFileYAML, oneSection) {
 191   std::unique_ptr<NormalizedFile> f = fromYAML(
 192     "---\n"
 193     "arch:      x86_64\n"
 194     "file-type: MH_OBJECT\n"
 195     "sections:\n"
 196     "  - segment:     __TEXT\n"
 197     "    section:     __text\n"
 198     "    type:        S_REGULAR\n"
 199     "    attributes:  [ S_ATTR_PURE_INSTRUCTIONS ]\n"
 200     "    alignment:   1\n"
 201     "    address:     0x12345678\n"
 202     "    content:     [ 0x90, 0x90 ]\n"
 203     "...\n");
 204   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
 205   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
 206   EXPECT_TRUE(f->localSymbols.empty());
 207   EXPECT_TRUE(f->globalSymbols.empty());
 208   EXPECT_TRUE(f->undefinedSymbols.empty());
 209   EXPECT_EQ(f->sections.size(), 1UL);
 210   const Section& sect = f->sections[0];
 211   EXPECT_TRUE(sect.segmentName.equals("__TEXT"));
 212   EXPECT_TRUE(sect.sectionName.equals("__text"));
 213   EXPECT_EQ((uint32_t)(sect.type), (uint32_t)(llvm::MachO::S_REGULAR));
 214   EXPECT_EQ((uint32_t)(sect.attributes),
 215                             (uint32_t)(llvm::MachO::S_ATTR_PURE_INSTRUCTIONS));
 216   EXPECT_EQ(sect.alignment, 1U);
 217   EXPECT_EQ((uint64_t)sect.address, 0x12345678ULL);
 218   EXPECT_EQ(sect.content.size(), 2UL);
 219   EXPECT_EQ((int)(sect.content[0]), 0x90);
 220   EXPECT_EQ((int)(sect.content[1]), 0x90);
 221 }
 222
 223
 224 TEST(ObjectFileYAML, hello_x86_64) {
 225   std::unique_ptr<NormalizedFile> f = fromYAML(
 226     "---\n"
 227     "arch:      x86_64\n"
 228     "file-type: MH_OBJECT\n"
 229     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
 230     "sections:\n"
 231     "  - segment:     __TEXT\n"
 232     "    section:     __text\n"
 233     "    type:        S_REGULAR\n"
 234     "    attributes:  [ S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS]\n"
 235     "    alignment:   0\n"
 236     "    address:     0x0000\n"
 237     "    content:     [ 0x55, 0x48, 0x89, 0xe5, 0x48, 0x8d, 0x3d, 0x00,\n"
 238     "                   0x00, 0x00, 0x00, 0x30, 0xc0, 0xe8, 0x00, 0x00,\n"
 239     "                   0x00, 0x00, 0x31, 0xc0, 0x5d, 0xc3 ]\n"
 240     "    relocations:\n"
 241     "     - offset:     0x0e\n"
 242     "       type:       X86_64_RELOC_BRANCH\n"
 243     "       length:     2\n"
 244     "       pc-rel:     true\n"
 245     "       extern:     true\n"
 246     "       symbol:     2\n"
 247     "     - offset:     0x07\n"
 248     "       type:       X86_64_RELOC_SIGNED\n"
 249     "       length:     2\n"
 250     "       pc-rel:     true\n"
 251     "       extern:     true\n"
 252     "       symbol:     1\n"
 253     "  - segment:     __TEXT\n"
 254     "    section:     __cstring\n"
 255     "    type:        S_CSTRING_LITERALS\n"
 256     "    attributes:  [ ]\n"
 257     "    alignment:   0\n"
 258     "    address:     0x0016\n"
 259     "    content:     [ 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x00 ]\n"
 260     "global-symbols:\n"
 261     "  - name:   _main\n"
 262     "    type:   N_SECT\n"
 263     "    scope:  [ N_EXT ]\n"
 264     "    sect:   1\n"
 265     "    value:  0x0\n"
 266     "local-symbols:\n"
 267     "  - name:   L_.str\n"
 268     "    type:   N_SECT\n"
 269     "    scope:  [ ]\n"
 270     "    sect:   2\n"
 271     "    value:  0x16\n"
 272     "undefined-symbols:\n"
 273     "  - name:   _printf\n"
 274     "    type:   N_UNDF\n"
 275     "    value:  0x0\n"
 276     "...\n");
 277   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
 278   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
 279   EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
 280   EXPECT_EQ(f->sections.size(), 2UL);
 281
 282   const Section& sect1 = f->sections[0];
 283   EXPECT_TRUE(sect1.segmentName.equals("__TEXT"));
 284   EXPECT_TRUE(sect1.sectionName.equals("__text"));
 285   EXPECT_EQ((uint32_t)(sect1.type), (uint32_t)(llvm::MachO::S_REGULAR));
 286   EXPECT_EQ((uint32_t)(sect1.attributes),
 287                             (uint32_t)(llvm::MachO::S_ATTR_PURE_INSTRUCTIONS
 288                                      | llvm::MachO::S_ATTR_SOME_INSTRUCTIONS));
 289   EXPECT_EQ(sect1.alignment, 0U);
 290   EXPECT_EQ((uint64_t)sect1.address, 0x0ULL);
 291   EXPECT_EQ(sect1.content.size(), 22UL);
 292   EXPECT_EQ((int)(sect1.content[0]), 0x55);
 293   EXPECT_EQ((int)(sect1.content[1]), 0x48);
 294   EXPECT_EQ(sect1.relocations.size(), 2UL);
 295   const Relocation& reloc1 = sect1.relocations[0];
 296   EXPECT_EQ(reloc1.offset, 0x0eU);
 297   EXPECT_FALSE(reloc1.scattered);
 298   EXPECT_EQ((int)reloc1.type, (int)llvm::MachO::X86_64_RELOC_BRANCH);
 299   EXPECT_EQ(reloc1.length, 2);
 300   EXPECT_TRUE(reloc1.pcRel);
 301   EXPECT_TRUE(reloc1.isExtern);
 302   EXPECT_EQ(reloc1.symbol, 2U);
 303   EXPECT_EQ((int)(reloc1.value), 0);
 304   const Relocation& reloc2 = sect1.relocations[1];
 305   EXPECT_EQ(reloc2.offset, 0x07U);
 306   EXPECT_FALSE(reloc2.scattered);
 307   EXPECT_EQ((int)reloc2.type, (int)llvm::MachO::X86_64_RELOC_SIGNED);
 308   EXPECT_EQ(reloc2.length, 2);
 309   EXPECT_TRUE(reloc2.pcRel);
 310   EXPECT_TRUE(reloc2.isExtern);
 311   EXPECT_EQ(reloc2.symbol, 1U);
 312   EXPECT_EQ((int)(reloc2.value), 0);
 313
 314   const Section& sect2 = f->sections[1];
 315   EXPECT_TRUE(sect2.segmentName.equals("__TEXT"));
 316   EXPECT_TRUE(sect2.sectionName.equals("__cstring"));
 317   EXPECT_EQ((uint32_t)(sect2.type), (uint32_t)(llvm::MachO::S_CSTRING_LITERALS));
 318   EXPECT_EQ((uint32_t)(sect2.attributes), 0U);
 319   EXPECT_EQ(sect2.alignment, 0U);
 320   EXPECT_EQ((uint64_t)sect2.address, 0x016ULL);
 321   EXPECT_EQ(sect2.content.size(), 7UL);
 322   EXPECT_EQ((int)(sect2.content[0]), 0x68);
 323   EXPECT_EQ((int)(sect2.content[1]), 0x65);
 324   EXPECT_EQ((int)(sect2.content[2]), 0x6c);
 325
 326   EXPECT_EQ(f->globalSymbols.size(), 1UL);
 327   const Symbol& sym1 = f->globalSymbols[0];
 328   EXPECT_TRUE(sym1.name.equals("_main"));
 329   EXPECT_EQ((int)(sym1.type), llvm::MachO::N_SECT);
 330   EXPECT_EQ((int)(sym1.scope), llvm::MachO::N_EXT);
 331   EXPECT_EQ(sym1.sect, 1);
 332   EXPECT_EQ((int)(sym1.desc), 0);
 333   EXPECT_EQ((uint64_t)sym1.value, 0x0ULL);
 334   EXPECT_EQ(f->localSymbols.size(), 1UL);
 335   const Symbol& sym2 = f->localSymbols[0];
 336   EXPECT_TRUE(sym2.name.equals("L_.str"));
 337   EXPECT_EQ((int)(sym2.type), llvm::MachO::N_SECT);
 338   EXPECT_EQ((int)(sym2.scope), 0);
 339   EXPECT_EQ(sym2.sect, 2);
 340   EXPECT_EQ((int)(sym2.desc), 0);
 341   EXPECT_EQ((uint64_t)sym2.value, 0x16ULL);
 342   EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
 343   const Symbol& sym3 = f->undefinedSymbols[0];
 344   EXPECT_TRUE(sym3.name.equals("_printf"));
 345   EXPECT_EQ((int)(sym3.type), llvm::MachO::N_UNDF);
 346   EXPECT_EQ((int)(sym3.scope), 0);
 347   EXPECT_EQ(sym3.sect, 0);
 348   EXPECT_EQ((int)(sym3.desc), 0);
 349   EXPECT_EQ((uint64_t)sym3.value, 0x0ULL);
 350 }
 351
 352
 353 TEST(ObjectFileYAML, hello_x86) {
 354   std::unique_ptr<NormalizedFile> f = fromYAML(
 355     "---\n"
 356     "arch:      x86\n"
 357     "file-type: MH_OBJECT\n"
 358     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
 359     "sections:\n"
 360     "  - segment:     __TEXT\n"
 361     "    section:     __text\n"
 362     "    type:        S_REGULAR\n"
 363     "    attributes:  [ S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS]\n"
 364     "    alignment:   0\n"
 365     "    address:     0x0000\n"
 366     "    content:     [ 0x55, 0x89, 0xe5, 0x83, 0xec, 0x08, 0xe8, 0x00,\n"
 367     "                   0x00, 0x00, 0x00, 0x58, 0x8d, 0x80, 0x16, 0x00,\n"
 368     "                   0x00, 0x00, 0x89, 0x04, 0x24, 0xe8, 0xe6, 0xff,\n"
 369     "                   0xff, 0xff, 0x31, 0xc0, 0x83, 0xc4, 0x08, 0x5d,\n"
 370     "                   0xc3 ]\n"
 371     "    relocations:\n"
 372     "     - offset:     0x16\n"
 373     "       type:       GENERIC_RELOC_VANILLA\n"
 374     "       length:     2\n"
 375     "       pc-rel:     true\n"
 376     "       extern:     true\n"
 377     "       symbol:     1\n"
 378     "     - offset:     0x0e\n"
 379     "       scattered:  true\n"
 380     "       type:       GENERIC_RELOC_LOCAL_SECTDIFF\n"
 381     "       length:     2\n"
 382     "       pc-rel:     false\n"
 383     "       value:      0x21\n"
 384     "     - offset:     0x0\n"
 385     "       scattered:  true\n"
 386     "       type:       GENERIC_RELOC_PAIR\n"
 387     "       length:     2\n"
 388     "       pc-rel:     false\n"
 389     "       value:      0xb\n"
 390     "  - segment:     __TEXT\n"
 391     "    section:     __cstring\n"
 392     "    type:        S_CSTRING_LITERALS\n"
 393     "    attributes:  [ ]\n"
 394     "    alignment:   0\n"
 395     "    address:     0x0021\n"
 396     "    content:     [ 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x00 ]\n"
 397     "global-symbols:\n"
 398     "  - name:   _main\n"
 399     "    type:   N_SECT\n"
 400     "    scope:  [ N_EXT ]\n"
 401     "    sect:   1\n"
 402     "    value:  0x0\n"
 403     "undefined-symbols:\n"
 404     "  - name:   _printf\n"
 405     "    type:   N_UNDF\n"
 406     "    value:  0x0\n"
 407     "...\n");
 408   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86);
 409   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
 410   EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
 411   EXPECT_EQ(f->sections.size(), 2UL);
 412
 413   const Section& sect1 = f->sections[0];
 414   EXPECT_TRUE(sect1.segmentName.equals("__TEXT"));
 415   EXPECT_TRUE(sect1.sectionName.equals("__text"));
 416   EXPECT_EQ((uint32_t)(sect1.type), (uint32_t)(llvm::MachO::S_REGULAR));
 417   EXPECT_EQ((uint32_t)(sect1.attributes),
 418                             (uint32_t)(llvm::MachO::S_ATTR_PURE_INSTRUCTIONS
 419                                      | llvm::MachO::S_ATTR_SOME_INSTRUCTIONS));
 420   EXPECT_EQ(sect1.alignment, 0U);
 421   EXPECT_EQ((uint64_t)sect1.address, 0x0ULL);
 422   EXPECT_EQ(sect1.content.size(), 33UL);
 423   EXPECT_EQ((int)(sect1.content[0]), 0x55);
 424   EXPECT_EQ((int)(sect1.content[1]), 0x89);
 425   EXPECT_EQ(sect1.relocations.size(), 3UL);
 426   const Relocation& reloc1 = sect1.relocations[0];
 427   EXPECT_EQ(reloc1.offset, 0x16U);
 428   EXPECT_FALSE(reloc1.scattered);
 429   EXPECT_EQ((int)reloc1.type, (int)llvm::MachO::GENERIC_RELOC_VANILLA);
 430   EXPECT_EQ(reloc1.length, 2);
 431   EXPECT_TRUE(reloc1.pcRel);
 432   EXPECT_TRUE(reloc1.isExtern);
 433   EXPECT_EQ(reloc1.symbol, 1U);
 434   EXPECT_EQ((int)(reloc1.value), 0);
 435   const Relocation& reloc2 = sect1.relocations[1];
 436   EXPECT_EQ(reloc2.offset, 0x0eU);
 437   EXPECT_TRUE(reloc2.scattered);
 438   EXPECT_EQ((int)reloc2.type, (int)llvm::MachO::GENERIC_RELOC_LOCAL_SECTDIFF);
 439   EXPECT_EQ(reloc2.length, 2);
 440   EXPECT_FALSE(reloc2.pcRel);
 441   EXPECT_EQ(reloc2.symbol, 0U);
 442   EXPECT_EQ((int)(reloc2.value), 0x21);
 443   const Relocation& reloc3 = sect1.relocations[2];
 444   EXPECT_EQ(reloc3.offset, 0U);
 445   EXPECT_TRUE(reloc3.scattered);
 446   EXPECT_EQ((int)reloc3.type, (int)llvm::MachO::GENERIC_RELOC_PAIR);
 447   EXPECT_EQ(reloc3.length, 2);
 448   EXPECT_FALSE(reloc3.pcRel);
 449   EXPECT_EQ(reloc3.symbol, 0U);
 450   EXPECT_EQ((int)(reloc3.value), 0xb);
 451
 452   const Section& sect2 = f->sections[1];
 453   EXPECT_TRUE(sect2.segmentName.equals("__TEXT"));
 454   EXPECT_TRUE(sect2.sectionName.equals("__cstring"));
 455   EXPECT_EQ((uint32_t)(sect2.type), (uint32_t)(llvm::MachO::S_CSTRING_LITERALS));
 456   EXPECT_EQ((uint32_t)(sect2.attributes), 0U);
 457   EXPECT_EQ(sect2.alignment, 0U);
 458   EXPECT_EQ((uint64_t)sect2.address, 0x021ULL);
 459   EXPECT_EQ(sect2.content.size(), 7UL);
 460   EXPECT_EQ((int)(sect2.content[0]), 0x68);
 461   EXPECT_EQ((int)(sect2.content[1]), 0x65);
 462   EXPECT_EQ((int)(sect2.content[2]), 0x6c);
 463
 464   EXPECT_EQ(f->globalSymbols.size(), 1UL);
 465   const Symbol& sym1 = f->globalSymbols[0];
 466   EXPECT_TRUE(sym1.name.equals("_main"));
 467   EXPECT_EQ((int)(sym1.type), llvm::MachO::N_SECT);
 468   EXPECT_EQ((int)(sym1.scope), llvm::MachO::N_EXT);
 469   EXPECT_EQ(sym1.sect, 1);
 470   EXPECT_EQ((int)(sym1.desc), 0);
 471   EXPECT_EQ((uint64_t)sym1.value, 0x0ULL);
 472   EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
 473   const Symbol& sym2 = f->undefinedSymbols[0];
 474   EXPECT_TRUE(sym2.name.equals("_printf"));
 475   EXPECT_EQ((int)(sym2.type), llvm::MachO::N_UNDF);
 476   EXPECT_EQ((int)(sym2.scope), 0);
 477   EXPECT_EQ(sym2.sect, 0);
 478   EXPECT_EQ((int)(sym2.desc), 0);
 479   EXPECT_EQ((uint64_t)sym2.value, 0x0ULL);
 480 }
 481
 482 TEST(ObjectFileYAML, hello_armv6) {
 483   std::unique_ptr<NormalizedFile> f = fromYAML(
 484     "---\n"
 485     "arch:      armv6\n"
 486     "file-type: MH_OBJECT\n"
 487     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
 488     "sections:\n"
 489     "  - segment:     __TEXT\n"
 490     "    section:     __text\n"
 491     "    type:        S_REGULAR\n"
 492     "    attributes:  [ S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS]\n"
 493     "    alignment:   2\n"
 494     "    address:     0x0000\n"
 495     "    content:     [ 0x80, 0x40, 0x2d, 0xe9, 0x10, 0x00, 0x9f, 0xe5,\n"
 496     "                   0x0d, 0x70, 0xa0, 0xe1, 0x00, 0x00, 0x8f, 0xe0,\n"
 497     "                   0xfa, 0xff, 0xff, 0xeb, 0x00, 0x00, 0xa0, 0xe3,\n"
 498     "                   0x80, 0x80, 0xbd, 0xe8, 0x0c, 0x00, 0x00, 0x00 ]\n"
 499     "    relocations:\n"
 500     "     - offset:     0x1c\n"
 501     "       scattered:  true\n"
 502     "       type:       ARM_RELOC_SECTDIFF\n"
 503     "       length:     2\n"
 504     "       pc-rel:     false\n"
 505     "       value:      0x20\n"
 506     "     - offset:     0x0\n"
 507     "       scattered:  true\n"
 508     "       type:       ARM_RELOC_PAIR\n"
 509     "       length:     2\n"
 510     "       pc-rel:     false\n"
 511     "       value:      0xc\n"
 512     "     - offset:     0x10\n"
 513     "       type:       ARM_RELOC_BR24\n"
 514     "       length:     2\n"
 515     "       pc-rel:     true\n"
 516     "       extern:     true\n"
 517     "       symbol:     1\n"
 518     "  - segment:     __TEXT\n"
 519     "    section:     __cstring\n"
 520     "    type:        S_CSTRING_LITERALS\n"
 521     "    attributes:  [ ]\n"
 522     "    alignment:   0\n"
 523     "    address:     0x0020\n"
 524     "    content:     [ 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x00 ]\n"
 525     "global-symbols:\n"
 526     "  - name:   _main\n"
 527     "    type:   N_SECT\n"
 528     "    scope:  [ N_EXT ]\n"
 529     "    sect:   1\n"
 530     "    value:  0x0\n"
 531     "undefined-symbols:\n"
 532     "  - name:   _printf\n"
 533     "    type:   N_UNDF\n"
 534     "    value:  0x0\n"
 535     "...\n");
 536   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv6);
 537   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
 538   EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
 539   EXPECT_EQ(f->sections.size(), 2UL);
 540
 541   const Section& sect1 = f->sections[0];
 542   EXPECT_TRUE(sect1.segmentName.equals("__TEXT"));
 543   EXPECT_TRUE(sect1.sectionName.equals("__text"));
 544   EXPECT_EQ((uint32_t)(sect1.type), (uint32_t)(llvm::MachO::S_REGULAR));
 545   EXPECT_EQ((uint32_t)(sect1.attributes),
 546                             (uint32_t)(llvm::MachO::S_ATTR_PURE_INSTRUCTIONS
 547                                      | llvm::MachO::S_ATTR_SOME_INSTRUCTIONS));
 548   EXPECT_EQ(sect1.alignment, 2U);
 549   EXPECT_EQ((uint64_t)sect1.address, 0x0ULL);
 550   EXPECT_EQ(sect1.content.size(), 32UL);
 551   EXPECT_EQ((int)(sect1.content[0]), 0x80);
 552   EXPECT_EQ((int)(sect1.content[1]), 0x40);
 553   EXPECT_EQ(sect1.relocations.size(), 3UL);
 554   const Relocation& reloc1 = sect1.relocations[0];
 555   EXPECT_EQ(reloc1.offset, 0x1cU);
 556   EXPECT_TRUE(reloc1.scattered);
 557   EXPECT_EQ((int)reloc1.type, (int)llvm::MachO::ARM_RELOC_SECTDIFF);
 558   EXPECT_EQ(reloc1.length, 2);
 559   EXPECT_FALSE(reloc1.pcRel);
 560   EXPECT_EQ(reloc1.symbol, 0U);
 561   EXPECT_EQ((int)(reloc1.value), 0x20);
 562   const Relocation& reloc2 = sect1.relocations[1];
 563   EXPECT_EQ(reloc2.offset, 0x0U);
 564   EXPECT_TRUE(reloc2.scattered);
 565   EXPECT_EQ((int)reloc2.type, (int)llvm::MachO::ARM_RELOC_PAIR);
 566   EXPECT_EQ(reloc2.length, 2);
 567   EXPECT_FALSE(reloc2.pcRel);
 568   EXPECT_EQ(reloc2.symbol, 0U);
 569   EXPECT_EQ((int)(reloc2.value), 0xc);
 570   const Relocation& reloc3 = sect1.relocations[2];
 571   EXPECT_EQ(reloc3.offset, 0x10U);
 572   EXPECT_FALSE(reloc3.scattered);
 573   EXPECT_EQ((int)reloc3.type, (int)llvm::MachO::ARM_RELOC_BR24);
 574   EXPECT_EQ(reloc3.length, 2);
 575   EXPECT_TRUE(reloc3.pcRel);
 576   EXPECT_TRUE(reloc3.isExtern);
 577   EXPECT_EQ(reloc3.symbol, 1U);
 578   EXPECT_EQ((int)(reloc3.value), 0);
 579
 580   const Section& sect2 = f->sections[1];
 581   EXPECT_TRUE(sect2.segmentName.equals("__TEXT"));
 582   EXPECT_TRUE(sect2.sectionName.equals("__cstring"));
 583   EXPECT_EQ((uint32_t)(sect2.type), (uint32_t)(llvm::MachO::S_CSTRING_LITERALS));
 584   EXPECT_EQ((uint32_t)(sect2.attributes), 0U);
 585   EXPECT_EQ(sect2.alignment, 0U);
 586   EXPECT_EQ((uint64_t)sect2.address, 0x020ULL);
 587   EXPECT_EQ(sect2.content.size(), 7UL);
 588   EXPECT_EQ((int)(sect2.content[0]), 0x68);
 589   EXPECT_EQ((int)(sect2.content[1]), 0x65);
 590   EXPECT_EQ((int)(sect2.content[2]), 0x6c);
 591
 592   EXPECT_EQ(f->globalSymbols.size(), 1UL);
 593   const Symbol& sym1 = f->globalSymbols[0];
 594   EXPECT_TRUE(sym1.name.equals("_main"));
 595   EXPECT_EQ((int)(sym1.type), llvm::MachO::N_SECT);
 596   EXPECT_EQ((int)(sym1.scope), llvm::MachO::N_EXT);
 597   EXPECT_EQ(sym1.sect, 1);
 598   EXPECT_EQ((int)(sym1.desc), 0);
 599   EXPECT_EQ((uint64_t)sym1.value, 0x0ULL);
 600   EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
 601   const Symbol& sym2 = f->undefinedSymbols[0];
 602   EXPECT_TRUE(sym2.name.equals("_printf"));
 603   EXPECT_EQ((int)(sym2.type), llvm::MachO::N_UNDF);
 604   EXPECT_EQ((int)(sym2.scope), 0);
 605   EXPECT_EQ(sym2.sect, 0);
 606   EXPECT_EQ((int)(sym2.desc), 0);
 607   EXPECT_EQ((uint64_t)sym2.value, 0x0ULL);
 608 }
 609
 610
 611
 612 TEST(ObjectFileYAML, hello_armv7) {
 613   std::unique_ptr<NormalizedFile> f = fromYAML(
 614     "---\n"
 615     "arch:      armv7\n"
 616     "file-type: MH_OBJECT\n"
 617     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
 618     "sections:\n"
 619     "  - segment:     __TEXT\n"
 620     "    section:     __text\n"
 621     "    type:        S_REGULAR\n"
 622     "    attributes:  [ S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS]\n"
 623     "    alignment:   1\n"
 624     "    address:     0x0000\n"
 625     "    content:     [ 0x80, 0xb5, 0x40, 0xf2, 0x06, 0x00, 0x6f, 0x46,\n"
 626     "                   0xc0, 0xf2, 0x00, 0x00, 0x78, 0x44, 0xff, 0xf7,\n"
 627     "                   0xf8, 0xef, 0x00, 0x20, 0x80, 0xbd ]\n"
 628     "    relocations:\n"
 629     "     - offset:     0x0e\n"
 630     "       type:       ARM_THUMB_RELOC_BR22\n"
 631     "       length:     2\n"
 632     "       pc-rel:     true\n"
 633     "       extern:     true\n"
 634     "       symbol:     1\n"
 635     "     - offset:     0x08\n"
 636     "       scattered:  true\n"
 637     "       type:       ARM_RELOC_HALF_SECTDIFF\n"
 638     "       length:     3\n"
 639     "       pc-rel:     false\n"
 640     "       value:      0x16\n"
 641     "     - offset:     0x06\n"
 642     "       scattered:  true\n"
 643     "       type:       ARM_RELOC_PAIR\n"
 644     "       length:     3\n"
 645     "       pc-rel:     false\n"
 646     "       value:      0xc\n"
 647     "     - offset:     0x02\n"
 648     "       scattered:  true\n"
 649     "       type:       ARM_RELOC_HALF_SECTDIFF\n"
 650     "       length:     2\n"
 651     "       pc-rel:     false\n"
 652     "       value:      0x16\n"
 653     "     - offset:     0x0\n"
 654     "       scattered:  true\n"
 655     "       type:       ARM_RELOC_PAIR\n"
 656     "       length:     2\n"
 657     "       pc-rel:     false\n"
 658     "       value:      0xc\n"
 659     "  - segment:     __TEXT\n"
 660     "    section:     __cstring\n"
 661     "    type:        S_CSTRING_LITERALS\n"
 662     "    attributes:  [ ]\n"
 663     "    alignment:   0\n"
 664     "    address:     0x0016\n"
 665     "    content:     [ 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x00 ]\n"
 666     "global-symbols:\n"
 667     "  - name:   _main\n"
 668     "    type:   N_SECT\n"
 669     "    scope:  [ N_EXT ]\n"
 670     "    sect:   1\n"
 671     "    desc:   [ N_ARM_THUMB_DEF ]\n"
 672     "    value:  0x0\n"
 673     "undefined-symbols:\n"
 674     "  - name:   _printf\n"
 675     "    type:   N_UNDF\n"
 676     "    value:  0x0\n"
 677     "...\n");
 678   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_armv7);
 679   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
 680   EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
 681   EXPECT_EQ(f->sections.size(), 2UL);
 682
 683   const Section& sect1 = f->sections[0];
 684   EXPECT_TRUE(sect1.segmentName.equals("__TEXT"));
 685   EXPECT_TRUE(sect1.sectionName.equals("__text"));
 686   EXPECT_EQ((uint32_t)(sect1.type), (uint32_t)(llvm::MachO::S_REGULAR));
 687   EXPECT_EQ((uint32_t)(sect1.attributes),
 688                             (uint32_t)(llvm::MachO::S_ATTR_PURE_INSTRUCTIONS
 689                                      | llvm::MachO::S_ATTR_SOME_INSTRUCTIONS));
 690   EXPECT_EQ(sect1.alignment, 1U);
 691   EXPECT_EQ((uint64_t)sect1.address, 0x0ULL);
 692   EXPECT_EQ(sect1.content.size(), 22UL);
 693   EXPECT_EQ((int)(sect1.content[0]), 0x80);
 694   EXPECT_EQ((int)(sect1.content[1]), 0xb5);
 695   EXPECT_EQ(sect1.relocations.size(), 5UL);
 696   const Relocation& reloc1 = sect1.relocations[0];
 697   EXPECT_EQ(reloc1.offset, 0x0eU);
 698   EXPECT_FALSE(reloc1.scattered);
 699   EXPECT_EQ((int)reloc1.type, (int)llvm::MachO::ARM_THUMB_RELOC_BR22);
 700   EXPECT_EQ(reloc1.length, 2);
 701   EXPECT_TRUE(reloc1.pcRel);
 702   EXPECT_TRUE(reloc1.isExtern);
 703   EXPECT_EQ(reloc1.symbol, 1U);
 704   EXPECT_EQ((int)(reloc1.value), 0);
 705   const Relocation& reloc2 = sect1.relocations[1];
 706   EXPECT_EQ(reloc2.offset, 0x8U);
 707   EXPECT_TRUE(reloc2.scattered);
 708   EXPECT_EQ((int)reloc2.type, (int)llvm::MachO::ARM_RELOC_HALF_SECTDIFF);
 709   EXPECT_EQ(reloc2.length, 3);
 710   EXPECT_FALSE(reloc2.pcRel);
 711   EXPECT_EQ(reloc2.symbol, 0U);
 712   EXPECT_EQ((int)(reloc2.value), 0x16);
 713   const Relocation& reloc3 = sect1.relocations[2];
 714   EXPECT_EQ(reloc3.offset, 0x6U);
 715   EXPECT_TRUE(reloc3.scattered);
 716   EXPECT_EQ((int)reloc3.type, (int)llvm::MachO::ARM_RELOC_PAIR);
 717   EXPECT_EQ(reloc3.length, 3);
 718   EXPECT_FALSE(reloc3.pcRel);
 719   EXPECT_EQ(reloc3.symbol, 0U);
 720   EXPECT_EQ((int)(reloc3.value), 0xc);
 721    const Relocation& reloc4 = sect1.relocations[3];
 722   EXPECT_EQ(reloc4.offset, 0x2U);
 723   EXPECT_TRUE(reloc4.scattered);
 724   EXPECT_EQ((int)reloc4.type, (int)llvm::MachO::ARM_RELOC_HALF_SECTDIFF);
 725   EXPECT_EQ(reloc4.length, 2);
 726   EXPECT_FALSE(reloc4.pcRel);
 727   EXPECT_EQ(reloc4.symbol, 0U);
 728   EXPECT_EQ((int)(reloc4.value), 0x16);
 729   const Relocation& reloc5 = sect1.relocations[4];
 730   EXPECT_EQ(reloc5.offset, 0x0U);
 731   EXPECT_TRUE(reloc5.scattered);
 732   EXPECT_EQ((int)reloc5.type, (int)llvm::MachO::ARM_RELOC_PAIR);
 733   EXPECT_EQ(reloc5.length, 2);
 734   EXPECT_FALSE(reloc5.pcRel);
 735   EXPECT_EQ(reloc5.symbol, 0U);
 736   EXPECT_EQ((int)(reloc5.value), 0xc);
 737
 738   const Section& sect2 = f->sections[1];
 739   EXPECT_TRUE(sect2.segmentName.equals("__TEXT"));
 740   EXPECT_TRUE(sect2.sectionName.equals("__cstring"));
 741   EXPECT_EQ((uint32_t)(sect2.type), (uint32_t)(llvm::MachO::S_CSTRING_LITERALS));
 742   EXPECT_EQ((uint32_t)(sect2.attributes), 0U);
 743   EXPECT_EQ(sect2.alignment, 0U);
 744   EXPECT_EQ((uint64_t)sect2.address, 0x016ULL);
 745   EXPECT_EQ(sect2.content.size(), 7UL);
 746   EXPECT_EQ((int)(sect2.content[0]), 0x68);
 747   EXPECT_EQ((int)(sect2.content[1]), 0x65);
 748   EXPECT_EQ((int)(sect2.content[2]), 0x6c);
 749
 750   EXPECT_EQ(f->globalSymbols.size(), 1UL);
 751   const Symbol& sym1 = f->globalSymbols[0];
 752   EXPECT_TRUE(sym1.name.equals("_main"));
 753   EXPECT_EQ((int)(sym1.type), llvm::MachO::N_SECT);
 754   EXPECT_EQ((int)(sym1.scope), llvm::MachO::N_EXT);
 755   EXPECT_EQ(sym1.sect, 1);
 756   EXPECT_EQ((int)(sym1.desc), (int)(llvm::MachO::N_ARM_THUMB_DEF));
 757   EXPECT_EQ((uint64_t)sym1.value, 0x0ULL);
 758   EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
 759   const Symbol& sym2 = f->undefinedSymbols[0];
 760   EXPECT_TRUE(sym2.name.equals("_printf"));
 761   EXPECT_EQ((int)(sym2.type), llvm::MachO::N_UNDF);
 762   EXPECT_EQ((int)(sym2.scope), 0);
 763   EXPECT_EQ(sym2.sect, 0);
 764   EXPECT_EQ((int)(sym2.desc), 0);
 765   EXPECT_EQ((uint64_t)sym2.value, 0x0ULL);
 766 }