mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-14 11:32:34 +00:00
3d218156f8
The constructors of classes deriving from Binary normally take an error_code as an argument to the constructor. My original intent was to change them to have a trivial constructor and move the initial parsing logic to a static method returning an ErrorOr. I changed my mind because: * A constructor with an error_code out parameter is extremely convenient from the implementation side. We can incrementally construct the object and give up when we find an error. * It is very efficient when constructing on the stack or when there is no error. The only inefficient case is where heap allocating and an error is found (we have to free the memory). The result is that this is a much smaller patch. It just standardizes the create* helpers to return an ErrorOr. Almost no functionality change: The only difference is that this found that we were trying to read past the end of COFF import library but ignoring the error. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199770 91177308-0d34-0410-b5e6-96231b3b80d8
105 lines
2.6 KiB
C++
105 lines
2.6 KiB
C++
//===- MachOUniversal.h - Mach-O universal binaries -------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file declares Mach-O fat/universal binaries.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_OBJECT_MACHOUNIVERSAL_H
|
|
#define LLVM_OBJECT_MACHOUNIVERSAL_H
|
|
|
|
#include "llvm/ADT/OwningPtr.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/ADT/Triple.h"
|
|
#include "llvm/Object/Binary.h"
|
|
#include "llvm/Support/ErrorOr.h"
|
|
#include "llvm/Support/MachO.h"
|
|
|
|
namespace llvm {
|
|
namespace object {
|
|
|
|
class ObjectFile;
|
|
|
|
class MachOUniversalBinary : public Binary {
|
|
virtual void anchor();
|
|
|
|
uint32_t NumberOfObjects;
|
|
public:
|
|
class ObjectForArch {
|
|
const MachOUniversalBinary *Parent;
|
|
/// \brief Index of object in the universal binary.
|
|
uint32_t Index;
|
|
/// \brief Descriptor of the object.
|
|
MachO::fat_arch Header;
|
|
|
|
public:
|
|
ObjectForArch(const MachOUniversalBinary *Parent, uint32_t Index);
|
|
|
|
void clear() {
|
|
Parent = 0;
|
|
Index = 0;
|
|
}
|
|
|
|
bool operator==(const ObjectForArch &Other) const {
|
|
return (Parent == Other.Parent) && (Index == Other.Index);
|
|
}
|
|
|
|
ObjectForArch getNext() const { return ObjectForArch(Parent, Index + 1); }
|
|
uint32_t getCPUType() const { return Header.cputype; }
|
|
|
|
error_code getAsObjectFile(OwningPtr<ObjectFile> &Result) const;
|
|
};
|
|
|
|
class object_iterator {
|
|
ObjectForArch Obj;
|
|
public:
|
|
object_iterator(const ObjectForArch &Obj) : Obj(Obj) {}
|
|
const ObjectForArch* operator->() const {
|
|
return &Obj;
|
|
}
|
|
|
|
bool operator==(const object_iterator &Other) const {
|
|
return Obj == Other.Obj;
|
|
}
|
|
bool operator!=(const object_iterator &Other) const {
|
|
return !(*this == Other);
|
|
}
|
|
|
|
object_iterator& operator++() { // Preincrement
|
|
Obj = Obj.getNext();
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
MachOUniversalBinary(MemoryBuffer *Source, error_code &ec);
|
|
static ErrorOr<MachOUniversalBinary*> create(MemoryBuffer *Source);
|
|
|
|
object_iterator begin_objects() const {
|
|
return ObjectForArch(this, 0);
|
|
}
|
|
object_iterator end_objects() const {
|
|
return ObjectForArch(0, 0);
|
|
}
|
|
|
|
uint32_t getNumberOfObjects() const { return NumberOfObjects; }
|
|
|
|
// Cast methods.
|
|
static inline bool classof(Binary const *V) {
|
|
return V->isMachOUniversalBinary();
|
|
}
|
|
|
|
error_code getObjectForArch(Triple::ArchType Arch,
|
|
OwningPtr<ObjectFile> &Result) const;
|
|
};
|
|
|
|
}
|
|
}
|
|
|
|
#endif
|