mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-12-28 14:36:34 +00:00
97 lines
3.5 KiB
C++
97 lines
3.5 KiB
C++
//===-- Target/TargetMachineRegistry.h - Target Registration ----*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file exposes two classes: the TargetMachineRegistry class, which allows
|
|
// tools to inspect all of registered targets, and the RegisterTarget class,
|
|
// which TargetMachine implementations should use to register themselves with
|
|
// the system.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_TARGET_TARGETMACHINEREGISTRY_H
|
|
#define LLVM_TARGET_TARGETMACHINEREGISTRY_H
|
|
|
|
#include "llvm/Support/Registry.h"
|
|
|
|
namespace llvm {
|
|
class Module;
|
|
class TargetMachine;
|
|
|
|
struct TargetMachineRegistryEntry {
|
|
const char *Name;
|
|
const char *ShortDesc;
|
|
TargetMachine *(*CtorFn)(const Module &, const std::string &);
|
|
unsigned (*ModuleMatchQualityFn)(const Module &M);
|
|
unsigned (*JITMatchQualityFn)();
|
|
|
|
public:
|
|
TargetMachineRegistryEntry(const char *N, const char *SD,
|
|
TargetMachine *(*CF)(const Module &, const std::string &),
|
|
unsigned (*MMF)(const Module &M),
|
|
unsigned (*JMF)())
|
|
: Name(N), ShortDesc(SD), CtorFn(CF), ModuleMatchQualityFn(MMF),
|
|
JITMatchQualityFn(JMF) {}
|
|
};
|
|
|
|
template<>
|
|
class RegistryTraits<TargetMachine> {
|
|
public:
|
|
typedef TargetMachineRegistryEntry entry;
|
|
|
|
static const char *nameof(const entry &Entry) { return Entry.Name; }
|
|
static const char *descof(const entry &Entry) { return Entry.ShortDesc; }
|
|
};
|
|
|
|
struct TargetMachineRegistry : public Registry<TargetMachine> {
|
|
/// getClosestStaticTargetForModule - Given an LLVM module, pick the best
|
|
/// target that is compatible with the module. If no close target can be
|
|
/// found, this returns null and sets the Error string to a reason.
|
|
static const entry *getClosestStaticTargetForModule(const Module &M,
|
|
std::string &Error);
|
|
|
|
/// getClosestTargetForJIT - Pick the best target that is compatible with
|
|
/// the current host. If no close target can be found, this returns null
|
|
/// and sets the Error string to a reason.
|
|
static const entry *getClosestTargetForJIT(std::string &Error);
|
|
|
|
};
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
/// RegisterTarget - This class is used to make targets automatically register
|
|
/// themselves with the tool they are linked. Targets should define an
|
|
/// instance of this and implement the static methods described in the
|
|
/// TargetMachine comments.
|
|
/// The type 'TargetMachineImpl' should provide a constructor with two
|
|
/// parameters:
|
|
/// - const Module& M: the module that is being compiled:
|
|
/// - const std::string& FS: target-specific string describing target
|
|
/// flavour.
|
|
|
|
template<class TargetMachineImpl>
|
|
struct RegisterTarget {
|
|
RegisterTarget(const char *Name, const char *ShortDesc)
|
|
: Entry(Name, ShortDesc, &Allocator,
|
|
&TargetMachineImpl::getModuleMatchQuality,
|
|
&TargetMachineImpl::getJITMatchQuality),
|
|
Node(Entry)
|
|
{}
|
|
|
|
private:
|
|
TargetMachineRegistry::entry Entry;
|
|
TargetMachineRegistry::node Node;
|
|
|
|
static TargetMachine *Allocator(const Module &M, const std::string &FS) {
|
|
return new TargetMachineImpl(M, FS);
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|