mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-24 19:52:54 +01:00
fb10587e50
Modules and ModuleProviders. Because the "ModuleProvider" simply materializes GlobalValues now, and doesn't provide modules, it's renamed to "GVMaterializer". Code that used to need a ModuleProvider to materialize Functions can now materialize the Functions directly. Functions no longer use a magic linkage to record that they're materializable; they simply ask the GVMaterializer. Because the C ABI must never change, we can't remove LLVMModuleProviderRef or the functions that refer to it. Instead, because Module now exposes the same functionality ModuleProvider used to, we store a Module* in any LLVMModuleProviderRef and translate in the wrapper methods. The bindings to other languages still use the ModuleProvider concept. It would probably be worth some time to update them to follow the C++ more closely, but I don't intend to do it. Fixes http://llvm.org/PR5737 and http://llvm.org/PR5735. llvm-svn: 94686
67 lines
2.3 KiB
C++
67 lines
2.3 KiB
C++
//===-- llvm/GVMaterializer.h - Interface for GV materializers --*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file provides an abstract interface for loading a module from some
|
|
// place. This interface allows incremental or random access loading of
|
|
// functions from the file. This is useful for applications like JIT compilers
|
|
// or interprocedural optimizers that do not need the entire program in memory
|
|
// at the same time.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef GVMATERIALIZER_H
|
|
#define GVMATERIALIZER_H
|
|
|
|
#include <string>
|
|
|
|
namespace llvm {
|
|
|
|
class Function;
|
|
class GlobalValue;
|
|
class Module;
|
|
|
|
class GVMaterializer {
|
|
protected:
|
|
GVMaterializer() {}
|
|
|
|
public:
|
|
virtual ~GVMaterializer();
|
|
|
|
/// isMaterializable - True if GV can be materialized from whatever backing
|
|
/// store this GVMaterializer uses and has not been materialized yet.
|
|
virtual bool isMaterializable(const GlobalValue *GV) const = 0;
|
|
|
|
/// isDematerializable - True if GV has been materialized and can be
|
|
/// dematerialized back to whatever backing store this GVMaterializer uses.
|
|
virtual bool isDematerializable(const GlobalValue *GV) const = 0;
|
|
|
|
/// Materialize - make sure the given GlobalValue is fully read. If the
|
|
/// module is corrupt, this returns true and fills in the optional string with
|
|
/// information about the problem. If successful, this returns false.
|
|
///
|
|
virtual bool Materialize(GlobalValue *GV, std::string *ErrInfo = 0) = 0;
|
|
|
|
/// Dematerialize - If the given GlobalValue is read in, and if the
|
|
/// GVMaterializer supports it, release the memory for the GV, and set it up
|
|
/// to be materialized lazily. If the Materializer doesn't support this
|
|
/// capability, this method is a noop.
|
|
///
|
|
virtual void Dematerialize(GlobalValue *) {}
|
|
|
|
/// MaterializeModule - make sure the entire Module has been completely read.
|
|
/// On error, this returns true and fills in the optional string with
|
|
/// information about the problem. If successful, this returns false.
|
|
///
|
|
virtual bool MaterializeModule(Module *M, std::string *ErrInfo = 0) = 0;
|
|
};
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|