lib/Object/Binary.cpp

   1 //===- Binary.cpp - A generic binary file -----------------------*- 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 Binary class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Object/Binary.h"
  15 #include "llvm/ADT/StringRef.h"
  16 #include "llvm/Support/MemoryBuffer.h"
  17 #include "llvm/Support/Path.h"
  18
  19 // Include headers for createBinary.
  20 #include "llvm/Object/Archive.h"
  21 #include "llvm/Object/COFF.h"
  22 #include "llvm/Object/ObjectFile.h"
  23
  24 using namespace llvm;
  25 using namespace object;
  26
  27 Binary::~Binary() {
  28   delete Data;
  29 }
  30
  31 Binary::Binary(unsigned int Type, MemoryBuffer *Source)
  32   : TypeID(Type)
  33   , Data(Source) {}
  34
  35 StringRef Binary::getData() const {
  36   return Data->getBuffer();
  37 }
  38
  39 StringRef Binary::getFileName() const {
  40   return Data->getBufferIdentifier();
  41 }
  42
  43 error_code object::createBinary(MemoryBuffer *Source,
  44                                 OwningPtr<Binary> &Result) {
  45   OwningPtr<MemoryBuffer> scopedSource(Source);
  46   if (!Source)
  47     return make_error_code(errc::invalid_argument);
  48   sys::LLVMFileType type = sys::IdentifyFileType(Source->getBufferStart(),
  49                                 static_cast<unsigned>(Source->getBufferSize()));
  50   error_code ec;
  51   switch (type) {
  52     case sys::Archive_FileType: {
  53       OwningPtr<Binary> ret(new Archive(scopedSource.take(), ec));
  54       if (ec) return ec;
  55       Result.swap(ret);
  56       return object_error::success;
  57     }
  58     case sys::ELF_Relocatable_FileType:
  59     case sys::ELF_Executable_FileType:
  60     case sys::ELF_SharedObject_FileType:
  61     case sys::ELF_Core_FileType: {
  62       OwningPtr<Binary> ret(
  63         ObjectFile::createELFObjectFile(scopedSource.take()));
  64       if (!ret)
  65         return object_error::invalid_file_type;
  66       Result.swap(ret);
  67       return object_error::success;
  68     }
  69     case sys::Mach_O_Object_FileType:
  70     case sys::Mach_O_Executable_FileType:
  71     case sys::Mach_O_FixedVirtualMemorySharedLib_FileType:
  72     case sys::Mach_O_Core_FileType:
  73     case sys::Mach_O_PreloadExecutable_FileType:
  74     case sys::Mach_O_DynamicallyLinkedSharedLib_FileType:
  75     case sys::Mach_O_DynamicLinker_FileType:
  76     case sys::Mach_O_Bundle_FileType:
  77     case sys::Mach_O_DynamicallyLinkedSharedLibStub_FileType: {
  78       OwningPtr<Binary> ret(
  79         ObjectFile::createMachOObjectFile(scopedSource.take()));
  80       if (!ret)
  81         return object_error::invalid_file_type;
  82       Result.swap(ret);
  83       return object_error::success;
  84     }
  85     case sys::COFF_FileType: {
  86       OwningPtr<Binary> ret(new COFFObjectFile(scopedSource.take(), ec));
  87       if (ec) return ec;
  88       Result.swap(ret);
  89       return object_error::success;
  90     }
  91     default: // Unrecognized object file format.
  92       return object_error::invalid_file_type;
  93   }
  94 }
  95
  96 error_code object::createBinary(StringRef Path, OwningPtr<Binary> &Result) {
  97   OwningPtr<MemoryBuffer> File;
  98   if (error_code ec = MemoryBuffer::getFileOrSTDIN(Path, File))
  99     return ec;
 100   return createBinary(File.take(), Result);
 101 }