2013-04-04 02:31:38 +08:00
|
|
|
//===-- llvm-readobj.h ----------------------------------------------------===//
|
2013-02-20 10:37:12 +08:00
|
|
|
//
|
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
|
//
|
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
2014-08-14 00:26:38 +08:00
|
|
|
#ifndef LLVM_TOOLS_LLVM_READOBJ_LLVM_READOBJ_H
|
|
|
|
|
#define LLVM_TOOLS_LLVM_READOBJ_LLVM_READOBJ_H
|
2013-02-20 10:37:12 +08:00
|
|
|
|
2013-04-04 02:31:38 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2015-12-05 05:29:53 +08:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2016-02-18 00:21:49 +08:00
|
|
|
#include "llvm/Support/ErrorOr.h"
|
2016-04-21 05:24:34 +08:00
|
|
|
#include "llvm/Support/Error.h"
|
2013-04-04 02:31:38 +08:00
|
|
|
#include <string>
|
2013-02-20 10:37:12 +08:00
|
|
|
|
|
|
|
|
namespace llvm {
|
2013-04-04 02:31:38 +08:00
|
|
|
namespace object {
|
|
|
|
|
class RelocationRef;
|
|
|
|
|
}
|
2013-02-20 10:37:12 +08:00
|
|
|
|
2013-04-04 02:31:38 +08:00
|
|
|
// Various helper functions.
|
2015-12-05 05:29:53 +08:00
|
|
|
LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg);
|
[CodeView] Decouple record deserialization from visitor dispatch.
Until now, our use case for the visitor has been to take a stream of bytes
representing a type stream, deserialize the records in sequence, and do
something with them, where "something" is determined by how the user
implements a particular set of callbacks on an abstract class.
For actually writing PDBs, however, we want to do the reverse. We have
some kind of description of the list of records in their in-memory format,
and we want to process each one. Perhaps by serializing them to a byte
stream, or perhaps by converting them from one description format (Yaml)
to another (in-memory representation).
This was difficult in the current model because deserialization and
invoking the callbacks were tightly coupled.
With this patch we change this so that TypeDeserializer is itself an
implementation of the particular set of callbacks. This decouples
deserialization from the iteration over a list of records and invocation
of the callbacks. TypeDeserializer is initialized with another
implementation of the callback interface, so that upon deserialization it
can pass the deserialized record through to the next set of callbacks. In
a sense this is like an implementation of the Decorator design pattern,
where the Deserializer is a decorator.
This will be useful for writing Pdbs from yaml, where we have a
description of the type records in Yaml format. In this case, the visitor
implementation would have each visitation callback method implemented in
such a way as to extract the proper set of fields from the Yaml, and it
could maintain state that builds up a list of these records. Finally at
the end we can pass this information through to another set of callbacks
which serializes them into a byte stream.
Reviewed By: majnemer, ruiu, rnk
Differential Revision: https://reviews.llvm.org/D23177
llvm-svn: 277871
2016-08-06 05:45:34 +08:00
|
|
|
void error(std::error_code EC);
|
2016-08-05 03:39:55 +08:00
|
|
|
void error(llvm::Error EC);
|
2017-05-04 01:11:11 +08:00
|
|
|
template <typename T> T error(llvm::Expected<T> &&E) {
|
|
|
|
|
error(E.takeError());
|
|
|
|
|
return std::move(*E);
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-18 00:21:49 +08:00
|
|
|
template <class T> T unwrapOrError(ErrorOr<T> EO) {
|
|
|
|
|
if (EO)
|
|
|
|
|
return *EO;
|
|
|
|
|
reportError(EO.getError().message());
|
|
|
|
|
}
|
2016-04-21 05:24:34 +08:00
|
|
|
template <class T> T unwrapOrError(Expected<T> EO) {
|
|
|
|
|
if (EO)
|
|
|
|
|
return *EO;
|
|
|
|
|
std::string Buf;
|
|
|
|
|
raw_string_ostream OS(Buf);
|
|
|
|
|
logAllUnhandledErrors(EO.takeError(), OS, "");
|
|
|
|
|
OS.flush();
|
|
|
|
|
reportError(Buf);
|
|
|
|
|
}
|
2013-04-04 02:31:38 +08:00
|
|
|
bool relocAddressLess(object::RelocationRef A,
|
|
|
|
|
object::RelocationRef B);
|
|
|
|
|
} // namespace llvm
|
|
|
|
|
|
|
|
|
|
namespace opts {
|
|
|
|
|
extern llvm::cl::list<std::string> InputFilenames;
|
|
|
|
|
extern llvm::cl::opt<bool> FileHeaders;
|
|
|
|
|
extern llvm::cl::opt<bool> Sections;
|
|
|
|
|
extern llvm::cl::opt<bool> SectionRelocations;
|
|
|
|
|
extern llvm::cl::opt<bool> SectionSymbols;
|
|
|
|
|
extern llvm::cl::opt<bool> SectionData;
|
|
|
|
|
extern llvm::cl::opt<bool> Relocations;
|
|
|
|
|
extern llvm::cl::opt<bool> Symbols;
|
|
|
|
|
extern llvm::cl::opt<bool> DynamicSymbols;
|
|
|
|
|
extern llvm::cl::opt<bool> UnwindInfo;
|
2013-04-12 12:01:52 +08:00
|
|
|
extern llvm::cl::opt<bool> ExpandRelocs;
|
2015-02-19 03:32:05 +08:00
|
|
|
extern llvm::cl::opt<bool> CodeView;
|
|
|
|
|
extern llvm::cl::opt<bool> CodeViewSubsectionBytes;
|
2014-01-30 12:46:33 +08:00
|
|
|
extern llvm::cl::opt<bool> ARMAttributes;
|
2014-06-18 16:47:09 +08:00
|
|
|
extern llvm::cl::opt<bool> MipsPLTGOT;
|
2016-03-02 05:45:22 +08:00
|
|
|
enum OutputStyleTy { LLVM, GNU };
|
|
|
|
|
extern llvm::cl::opt<OutputStyleTy> Output;
|
2013-04-04 02:31:38 +08:00
|
|
|
} // namespace opts
|
|
|
|
|
|
|
|
|
|
#define LLVM_READOBJ_ENUM_ENT(ns, enum) \
|
|
|
|
|
{ #enum, ns::enum }
|
2013-02-20 10:37:12 +08:00
|
|
|
|
2016-01-14 03:32:35 +08:00
|
|
|
#define LLVM_READOBJ_ENUM_CLASS_ENT(enum_class, enum) \
|
|
|
|
|
{ #enum, std::underlying_type<enum_class>::type(enum_class::enum) }
|
|
|
|
|
|
2013-02-20 10:37:12 +08:00
|
|
|
#endif
|