contrib/llvm/lib/Object/Archive.cpp

   1 //===- Archive.cpp - ar File Format implementation --------------*- C++ -*-===//
   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 // This file defines the ArchiveObjectFile class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Object/Archive.h"
  15 #include "llvm/ADT/APInt.h"
  16 #include "llvm/Support/Endian.h"
  17 #include "llvm/Support/MemoryBuffer.h"
  18
  19 using namespace llvm;
  20 using namespace object;
  21
  22 static const char *Magic = "!<arch>\n";
  23
  24 namespace {
  25 struct ArchiveMemberHeader {
  26   char Name[16];
  27   char LastModified[12];
  28   char UID[6];
  29   char GID[6];
  30   char AccessMode[8];
  31   char Size[10]; ///< Size of data, not including header or padding.
  32   char Terminator[2];
  33
  34   ///! Get the name without looking up long names.
  35   StringRef getName() const {
  36     char EndCond;
  37     if (Name[0] == '/' || Name[0] == '#')
  38       EndCond = ' ';
  39     else
  40       EndCond = '/';
  41     StringRef::size_type end = StringRef(Name, sizeof(Name)).find(EndCond);
  42     if (end == StringRef::npos)
  43       end = sizeof(Name);
  44     assert(end <= sizeof(Name) && end > 0);
  45     // Don't include the EndCond if there is one.
  46     return StringRef(Name, end);
  47   }
  48
  49   uint64_t getSize() const {
  50     APInt ret;
  51     StringRef(Size, sizeof(Size)).getAsInteger(10, ret);
  52     return ret.getZExtValue();
  53   }
  54 };
  55 }
  56
  57 static const ArchiveMemberHeader *ToHeader(const char *base) {
  58   return reinterpret_cast<const ArchiveMemberHeader *>(base);
  59 }
  60
  61
  62 static bool isInternalMember(const ArchiveMemberHeader &amh) {
  63   static const char *const internals[] = {
  64     "/",
  65     "//",
  66     "#_LLVM_SYM_TAB_#"
  67   };
  68
  69   StringRef name = amh.getName();
  70   for (std::size_t i = 0; i < sizeof(internals) / sizeof(*internals); ++i) {
  71     if (name == internals[i])
  72       return true;
  73   }
  74   return false;
  75 }
  76
  77 void Archive::anchor() { }
  78
  79 Archive::Child Archive::Child::getNext() const {
  80   size_t SpaceToSkip = sizeof(ArchiveMemberHeader) +
  81     ToHeader(Data.data())->getSize();
  82   // If it's odd, add 1 to make it even.
  83   if (SpaceToSkip & 1)
  84     ++SpaceToSkip;
  85
  86   const char *NextLoc = Data.data() + SpaceToSkip;
  87
  88   // Check to see if this is past the end of the archive.
  89   if (NextLoc >= Parent->Data->getBufferEnd())
  90     return Child(Parent, StringRef(0, 0));
  91
  92   size_t NextSize = sizeof(ArchiveMemberHeader) +
  93     ToHeader(NextLoc)->getSize();
  94
  95   return Child(Parent, StringRef(NextLoc, NextSize));
  96 }
  97
  98 error_code Archive::Child::getName(StringRef &Result) const {
  99   StringRef name = ToHeader(Data.data())->getName();
 100   // Check if it's a special name.
 101   if (name[0] == '/') {
 102     if (name.size() == 1) { // Linker member.
 103       Result = name;
 104       return object_error::success;
 105     }
 106     if (name.size() == 2 && name[1] == '/') { // String table.
 107       Result = name;
 108       return object_error::success;
 109     }
 110     // It's a long name.
 111     // Get the offset.
 112     APInt offset;
 113     name.substr(1).getAsInteger(10, offset);
 114     const char *addr = Parent->StringTable->Data.begin()
 115                        + sizeof(ArchiveMemberHeader)
 116                        + offset.getZExtValue();
 117     // Verify it.
 118     if (Parent->StringTable == Parent->end_children()
 119         || addr < (Parent->StringTable->Data.begin()
 120                    + sizeof(ArchiveMemberHeader))
 121         || addr > (Parent->StringTable->Data.begin()
 122                    + sizeof(ArchiveMemberHeader)
 123                    + Parent->StringTable->getSize()))
 124       return object_error::parse_failed;
 125     Result = addr;
 126     return object_error::success;
 127   } else if (name.startswith("#1/")) {
 128     APInt name_size;
 129     name.substr(3).getAsInteger(10, name_size);
 130     Result = Data.substr(0, name_size.getZExtValue());
 131     return object_error::success;
 132   }
 133   // It's a simple name.
 134   if (name[name.size() - 1] == '/')
 135     Result = name.substr(0, name.size() - 1);
 136   else
 137     Result = name;
 138   return object_error::success;
 139 }
 140
 141 uint64_t Archive::Child::getSize() const {
 142   uint64_t size = ToHeader(Data.data())->getSize();
 143   // Don't include attached name.
 144   StringRef name =  ToHeader(Data.data())->getName();
 145   if (name.startswith("#1/")) {
 146     APInt name_size;
 147     name.substr(3).getAsInteger(10, name_size);
 148     size -= name_size.getZExtValue();
 149   }
 150   return size;
 151 }
 152
 153 MemoryBuffer *Archive::Child::getBuffer() const {
 154   StringRef name;
 155   if (getName(name)) return NULL;
 156   int size = sizeof(ArchiveMemberHeader);
 157   if (name.startswith("#1/")) {
 158     APInt name_size;
 159     name.substr(3).getAsInteger(10, name_size);
 160     size += name_size.getZExtValue();
 161   }
 162   return MemoryBuffer::getMemBuffer(Data.substr(size, getSize()),
 163                                     name,
 164                                     false);
 165 }
 166
 167 error_code Archive::Child::getAsBinary(OwningPtr<Binary> &Result) const {
 168   OwningPtr<Binary> ret;
 169   if (error_code ec =
 170     createBinary(getBuffer(), ret))
 171     return ec;
 172   Result.swap(ret);
 173   return object_error::success;
 174 }
 175
 176 Archive::Archive(MemoryBuffer *source, error_code &ec)
 177   : Binary(Binary::ID_Archive, source) {
 178   // Check for sufficient magic.
 179   if (!source || source->getBufferSize()
 180                  < (8 + sizeof(ArchiveMemberHeader) + 2) // Smallest archive.
 181               || StringRef(source->getBufferStart(), 8) != Magic) {
 182     ec = object_error::invalid_file_type;
 183     return;
 184   }
 185
 186   // Get the special members.
 187   child_iterator i = begin_children(false);
 188   child_iterator e = end_children();
 189
 190   if (i != e) ++i; // Nobody cares about the first member.
 191   if (i != e) {
 192     SymbolTable = i;
 193     ++i;
 194   }
 195   if (i != e) {
 196     StringTable = i;
 197   }
 198
 199   ec = object_error::success;
 200 }
 201
 202 Archive::child_iterator Archive::begin_children(bool skip_internal) const {
 203   const char *Loc = Data->getBufferStart() + strlen(Magic);
 204   size_t Size = sizeof(ArchiveMemberHeader) +
 205     ToHeader(Loc)->getSize();
 206   Child c(this, StringRef(Loc, Size));
 207   // Skip internals at the beginning of an archive.
 208   if (skip_internal && isInternalMember(*ToHeader(Loc)))
 209     return c.getNext();
 210   return c;
 211 }
 212
 213 Archive::child_iterator Archive::end_children() const {
 214   return Child(this, StringRef(0, 0));
 215 }
 216
 217 error_code Archive::Symbol::getName(StringRef &Result) const {
 218   Result =
 219     StringRef(Parent->SymbolTable->getBuffer()->getBufferStart() + StringIndex);
 220   return object_error::success;
 221 }
 222
 223 error_code Archive::Symbol::getMember(child_iterator &Result) const {
 224   const char *buf = Parent->SymbolTable->getBuffer()->getBufferStart();
 225   uint32_t member_count = *reinterpret_cast<const support::ulittle32_t*>(buf);
 226   const char *offsets = buf + 4;
 227   buf += 4 + (member_count * 4); // Skip offsets.
 228   const char *indicies = buf + 4;
 229
 230   uint16_t offsetindex =
 231     *(reinterpret_cast<const support::ulittle16_t*>(indicies)
 232       + SymbolIndex);
 233
 234   uint32_t offset = *(reinterpret_cast<const support::ulittle32_t*>(offsets)
 235                       + (offsetindex - 1));
 236
 237   const char *Loc = Parent->getData().begin() + offset;
 238   size_t Size = sizeof(ArchiveMemberHeader) +
 239     ToHeader(Loc)->getSize();
 240   Result = Child(Parent, StringRef(Loc, Size));
 241
 242   return object_error::success;
 243 }
 244
 245 Archive::Symbol Archive::Symbol::getNext() const {
 246   Symbol t(*this);
 247   // Go to one past next null.
 248   t.StringIndex =
 249     Parent->SymbolTable->getBuffer()->getBuffer().find('\0', t.StringIndex) + 1;
 250   ++t.SymbolIndex;
 251   return t;
 252 }
 253
 254 Archive::symbol_iterator Archive::begin_symbols() const {
 255   const char *buf = SymbolTable->getBuffer()->getBufferStart();
 256   uint32_t member_count = *reinterpret_cast<const support::ulittle32_t*>(buf);
 257   buf += 4 + (member_count * 4); // Skip offsets.
 258   uint32_t symbol_count = *reinterpret_cast<const support::ulittle32_t*>(buf);
 259   buf += 4 + (symbol_count * 2); // Skip indices.
 260   uint32_t string_start_offset =
 261     buf - SymbolTable->getBuffer()->getBufferStart();
 262   return symbol_iterator(Symbol(this, 0, string_start_offset));
 263 }
 264
 265 Archive::symbol_iterator Archive::end_symbols() const {
 266   const char *buf = SymbolTable->getBuffer()->getBufferStart();
 267   uint32_t member_count = *reinterpret_cast<const support::ulittle32_t*>(buf);
 268   buf += 4 + (member_count * 4); // Skip offsets.
 269   uint32_t symbol_count = *reinterpret_cast<const support::ulittle32_t*>(buf);
 270   return symbol_iterator(
 271     Symbol(this, symbol_count, 0));
 272 }