Changes in directory llvm/include/llvm/CodeGen:
LinkAllCodegenComponents.h added (r1.1)
MachinePassRegistry.h added (r1.1)
---
Log message:
Forgot the added files for plugable machine passes.
---
Diffs of the changes: (+358 -0)
LinkAllCodegenComponents.h | 46 ++++++
MachinePassRegistry.h | 312 +++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 358 insertions(+)
Index: llvm/include/llvm/CodeGen/LinkAllCodegenComponents.h
diff -c /dev/null llvm/include/llvm/CodeGen/LinkAllCodegenComponents.h:1.1
*** /dev/null Tue Aug 1 11:31:18 2006
--- llvm/include/llvm/CodeGen/LinkAllCodegenComponents.h Tue Aug 1
11:31:08 2006
***************
*** 0 ****
--- 1,46 ----
+ //===- llvm/Codegen/LinkAllCodegenComponents.h ------------------*- C++
-*-===//
+ //
+ // The LLVM Compiler Infrastructure
+ //
+ // This file was developed by James M. Laskey and is distributed under the
+ // University of Illinois Open Source License. See LICENSE.TXT for details.
+ //
+
//===----------------------------------------------------------------------===//
+ //
+ // This header file pulls in all codegen related passes for tools like lli and
+ // llc that need this functionality.
+ //
+
//===----------------------------------------------------------------------===//
+
+ #ifndef LLVM_CODEGEN_LINKALLCODEGENCOMPONENTS_H
+ #define LLVM_CODEGEN_LINKALLCODEGENCOMPONENTS_H
+
+ #include "llvm/CodeGen/Passes.h"
+ #include "llvm/CodeGen/ScheduleDAG.h"
+
+ namespace {
+ struct ForceCodegenLinking {
+ ForceCodegenLinking() {
+ // We must reference the passes in such a way that compilers will not
+ // delete it all as dead code, even with whole program optimization,
+ // yet is effectively a NO-OP. As the compiler isn't smart enough
+ // to know that getenv() never returns -1, this will do the job.
+ if (std::getenv("bar") != (char*) -1)
+ return;
+
+ (void) llvm::createSimpleRegisterAllocator();
+ (void) llvm::createLocalRegisterAllocator();
+ (void) llvm::createLinearScanRegisterAllocator();
+
+ (void) llvm::createBFS_DAGScheduler(NULL, NULL);
+ (void) llvm::createSimpleDAGScheduler(NULL, NULL);
+ (void) llvm::createNoItinsDAGScheduler(NULL, NULL);
+ (void) llvm::createBURRListDAGScheduler(NULL, NULL);
+ (void) llvm::createTDRRListDAGScheduler(NULL, NULL);
+ (void) llvm::createTDListDAGScheduler(NULL, NULL);
+
+ }
+ } ForceCodegenLinking; // Force link by creating a global definition.
+ }
+
+ #endif
\ No newline at end of file
Index: llvm/include/llvm/CodeGen/MachinePassRegistry.h
diff -c /dev/null llvm/include/llvm/CodeGen/MachinePassRegistry.h:1.1
*** /dev/null Tue Aug 1 11:31:24 2006
--- llvm/include/llvm/CodeGen/MachinePassRegistry.h Tue Aug 1 11:31:08 2006
***************
*** 0 ****
--- 1,312 ----
+ //===-- llvm/CodeGen/MachinePassRegistry.h ----------------------*- C++
-*-===//
+ //
+ // The LLVM Compiler Infrastructure
+ //
+ // This file was developed by the LLVM research group and is distributed under
+ // the University of Illinois Open Source License. See LICENSE.TXT for
details.
+ //
+
//===----------------------------------------------------------------------===//
+
+ #ifndef LLVM_CODEGEN_MACHINEPASSREGISTRY_H
+ #define LLVM_CODEGEN_MACHINEPASSREGISTRY_H
+
+ #include "llvm/CodeGen/Passes.h"
+ #include "llvm/CodeGen/ScheduleDAG.h"
+ #include "llvm/Support/CommandLine.h"
+
+ #include <iostream>
+
+ namespace llvm {
+
+
+
//===----------------------------------------------------------------------===//
+ ///
+ /// MachinePassRegistryListener - Listener to adds and removals of nodes in
+ /// registration list.
+ ///
+
//===----------------------------------------------------------------------===//
+ class MachinePassRegistryListener {
+ public:
+ MachinePassRegistryListener() {}
+ virtual ~MachinePassRegistryListener() {}
+ virtual void NotifyAdd(const char *N, const char *D) = 0;
+ virtual void NotifyRemove(const char *N, const char *D) = 0;
+ };
+
+
+
//===----------------------------------------------------------------------===//
+ ///
+ /// MachinePassRegistryNode - Machine pass node stored in registration list.
+ ///
+
//===----------------------------------------------------------------------===//
+ template<typename FunctionPassCtor>
+ class MachinePassRegistryNode {
+
+ private:
+
+ MachinePassRegistryNode<FunctionPassCtor> *Next;// Next function pass in
list.
+ const char *Name; // Name of function pass.
+ const char *Description; // Description string.
+ FunctionPassCtor Ctor; // Function pass creator.
+
+ public:
+
+ MachinePassRegistryNode(const char *N, const char *D, FunctionPassCtor C)
+ : Next(NULL)
+ , Name(N)
+ , Description(D)
+ , Ctor(C)
+ {}
+
+ // Accessors
+ MachinePassRegistryNode<FunctionPassCtor> *getNext()
+ const { return Next; }
+ MachinePassRegistryNode<FunctionPassCtor> **getNextAddress()
+ { return &Next; }
+ const char *getName() const { return Name; }
+ const char *getDescription() const { return Description; }
+ FunctionPassCtor getCtor() const { return Ctor; }
+ void setNext(MachinePassRegistryNode<FunctionPassCtor> *N) { Next = N; }
+
+ };
+
+
+
//===----------------------------------------------------------------------===//
+ ///
+ /// MachinePassRegistry - Track the registration of machine passes.
+ ///
+
//===----------------------------------------------------------------------===//
+ template<typename FunctionPassCtor>
+ class MachinePassRegistry {
+
+ private:
+
+ MachinePassRegistryNode<FunctionPassCtor> *List;
+ // List of registry nodes.
+ FunctionPassCtor Cache; // Cached function pass creator.
+ MachinePassRegistryListener* Listener;// Listener for list adds are removes.
+
+ public:
+
+ // NO CONSTRUCTOR - we don't want static constructor ordering to mess
+ // with the registry.
+
+ // Accessors.
+ //
+ MachinePassRegistryNode<FunctionPassCtor> *getList() { return List; }
+ FunctionPassCtor getCache() { return Cache; }
+ void setCache(FunctionPassCtor C) { Cache = C; }
+ void setListener(MachinePassRegistryListener *L) { Listener = L; }
+
+ /// Add - Adds a function pass to the registration list.
+ ///
+ void Add(MachinePassRegistryNode<FunctionPassCtor> *Node) {
+ Node->setNext(List);
+ List = Node;
+ if (Listener) Listener->NotifyAdd(Node->getName(),
Node->getDescription());
+ }
+
+
+ /// Remove - Removes a function pass from the registration list.
+ ///
+ void Remove(MachinePassRegistryNode<FunctionPassCtor> *Node) {
+ for (MachinePassRegistryNode<FunctionPassCtor> **I = &List;
+ *I; I = (*I)->getNextAddress()) {
+ if (*I == Node) {
+ #if 0 // FIXME: Command opt needs to call a termination routine.
+ if (Listener) Listener->NotifyRemove(Node->getName(),
+ Node->getDescription());
+ #endif
+ *I = (*I)->getNext();
+ break;
+ }
+ }
+ }
+
+
+ /// FInd - Finds and returns a function pass in registration list, otherwise
+ /// returns NULL.
+ MachinePassRegistryNode<FunctionPassCtor> *Find(const char *Name) {
+ for (MachinePassRegistryNode<FunctionPassCtor> *I = List;
+ I; I = I->getNext()) {
+ if (std::string(Name) == std::string(I->getName())) return I;
+ }
+ return NULL;
+ }
+
+
+ };
+
+
+
//===----------------------------------------------------------------------===//
+ ///
+ /// RegisterRegAlloc class - Track the registration of register allocators.
+ ///
+
//===----------------------------------------------------------------------===//
+ class RegisterRegAlloc : public MachinePassRegistryNode<FunctionPass *(*)()> {
+
+ public:
+
+ typedef FunctionPass *(*FunctionPassCtor)();
+
+ static MachinePassRegistry<FunctionPassCtor> Registry;
+
+ RegisterRegAlloc(const char *N, const char *D, FunctionPassCtor C)
+ : MachinePassRegistryNode<FunctionPassCtor>(N, D, C)
+ { Registry.Add(this); }
+ ~RegisterRegAlloc() { Registry.Remove(this); }
+
+
+ // Accessors.
+ //
+ RegisterRegAlloc *getNext() const {
+ return (RegisterRegAlloc *)
+ MachinePassRegistryNode<FunctionPassCtor>::getNext();
+ }
+ static RegisterRegAlloc *getList() {
+ return (RegisterRegAlloc *)Registry.getList();
+ }
+ static FunctionPassCtor getCache() {
+ return Registry.getCache();
+ }
+ static void setCache(FunctionPassCtor C) {
+ Registry.setCache(C);
+ }
+ static void setListener(MachinePassRegistryListener *L) {
+ Registry.setListener(L);
+ }
+
+
+ /// FirstCtor - Finds the first register allocator in registration
+ /// list and returns its creator function, otherwise return NULL.
+ static FunctionPassCtor FirstCtor() {
+ MachinePassRegistryNode<FunctionPassCtor> *Node = Registry.getList();
+ return Node ? Node->getCtor() : NULL;
+ }
+
+ /// FindCtor - Finds a register allocator in registration list and returns
+ /// its creator function, otherwise return NULL.
+ static FunctionPassCtor FindCtor(const char *N) {
+ MachinePassRegistryNode<FunctionPassCtor> *Node = Registry.Find(N);
+ return Node ? Node->getCtor() : NULL;
+ }
+
+ };
+
+
+
//===----------------------------------------------------------------------===//
+ ///
+ /// RegisterScheduler class - Track the registration of instruction
schedulers.
+ ///
+
//===----------------------------------------------------------------------===//
+
+ class ScheduleDAG;
+ class SelectionDAG;
+ class MachineBasicBlock;
+
+ class RegisterScheduler : public
+ MachinePassRegistryNode<ScheduleDAG *(*)(SelectionDAG*,
MachineBasicBlock*)> {
+
+ public:
+
+ typedef ScheduleDAG *(*FunctionPassCtor)(SelectionDAG*, MachineBasicBlock*);
+
+ static MachinePassRegistry<FunctionPassCtor> Registry;
+
+ RegisterScheduler(const char *N, const char *D, FunctionPassCtor C)
+ : MachinePassRegistryNode<FunctionPassCtor>(N, D, C)
+ { Registry.Add(this); }
+ ~RegisterScheduler() { Registry.Remove(this); }
+
+
+ // Accessors.
+ //
+ RegisterScheduler *getNext() const {
+ return (RegisterScheduler *)
+ MachinePassRegistryNode<FunctionPassCtor>::getNext();
+ }
+ static RegisterScheduler *getList() {
+ return (RegisterScheduler *)Registry.getList();
+ }
+ static FunctionPassCtor getCache() {
+ return Registry.getCache();
+ }
+ static void setCache(FunctionPassCtor C) {
+ Registry.setCache(C);
+ }
+ static void setListener(MachinePassRegistryListener *L) {
+ Registry.setListener(L);
+ }
+
+
+ /// FirstCtor - Finds the first instruction scheduler in registration
+ /// list and returns its creator function, otherwise return NULL.
+ static FunctionPassCtor FirstCtor() {
+ MachinePassRegistryNode<FunctionPassCtor> *Node = Registry.getList();
+ return Node ? Node->getCtor() : NULL;
+ }
+
+
+ /// FindCtor - Finds a instruction scheduler in registration list and
returns
+ /// its creator function, otherwise return NULL.
+ static FunctionPassCtor FindCtor(const char *N) {
+ MachinePassRegistryNode<FunctionPassCtor> *Node = Registry.Find(N);
+ return Node ? Node->getCtor() : NULL;
+ }
+
+ };
+
+
+
//===----------------------------------------------------------------------===//
+ ///
+ /// RegisterPassParser class - Handle the addition of new machine passes.
+ ///
+
//===----------------------------------------------------------------------===//
+ template<class RegistryClass>
+ class RegisterPassParser : public MachinePassRegistryListener,
+ public cl::parser<const char *> {
+ public:
+ RegisterPassParser() {}
+
+ void initialize(cl::Option &O) {
+ cl::parser<const char *>::initialize(O);
+
+ // Add existing passes to option.
+ for (RegistryClass *Node = RegistryClass::getList();
+ Node; Node = Node->getNext()) {
+ addLiteralOption(Node->getName(), Node->getName(),
+ Node->getDescription());
+ }
+
+ // Make sure we listen for list changes.
+ RegistryClass::setListener(this);
+ }
+
+ // Implement the MachinePassRegistryListener callbacks.
+ //
+ virtual void NotifyAdd(const char *N, const char *D) {
+ addLiteralOption(N, N, D);
+ }
+ virtual void NotifyRemove(const char *N, const char *D) {
+ removeLiteralOption(N);
+ }
+
+ // ValLessThan - Provide a sorting comparator for Values elements...
+ typedef std::pair<const char*, std::pair<const char*, const char*> >
ValType;
+ static bool ValLessThan(const ValType &VT1, const ValType &VT2) {
+ return std::string(VT1.first) < std::string(VT2.first);
+ }
+
+ // printOptionInfo - Print out information about this option. Override the
+ // default implementation to sort the table before we print...
+ virtual void printOptionInfo(const cl::Option &O, unsigned GlobalWidth)
const{
+ RegisterPassParser *PNP = const_cast<RegisterPassParser*>(this);
+ std::sort(PNP->Values.begin(), PNP->Values.end(), ValLessThan);
+ cl::parser<const char *>::printOptionInfo(O, GlobalWidth);
+ }
+ };
+
+
+ } // end namespace llvm
+
+ #endif
_______________________________________________
llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
