1
0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-31 07:52:55 +01:00
llvm-mirror/tools/lto/LTOModule.h
Chandler Carruth 4c1f3c24db Move all of the header files which are involved in modelling the LLVM IR
into their new header subdirectory: include/llvm/IR. This matches the
directory structure of lib, and begins to correct a long standing point
of file layout clutter in LLVM.

There are still more header files to move here, but I wanted to handle
them in separate commits to make tracking what files make sense at each
layer easier.

The only really questionable files here are the target intrinsic
tablegen files. But that's a battle I'd rather not fight today.

I've updated both CMake and Makefile build systems (I think, and my
tests think, but I may have missed something).

I've also re-sorted the includes throughout the project. I'll be
committing updates to Clang, DragonEgg, and Polly momentarily.

llvm-svn: 171366
2013-01-02 11:36:10 +00:00

192 lines
6.9 KiB
C++

//===-LTOModule.h - LLVM Link Time Optimizer ------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the LTOModule class.
//
//===----------------------------------------------------------------------===//
#ifndef LTO_MODULE_H
#define LTO_MODULE_H
#include "llvm-c/lto.h"
#include "llvm/ADT/OwningPtr.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/IR/Module.h"
#include "llvm/MC/MCContext.h"
#include "llvm/Target/Mangler.h"
#include "llvm/Target/TargetMachine.h"
#include <string>
#include <vector>
// Forward references to llvm classes.
namespace llvm {
class Function;
class GlobalValue;
class MemoryBuffer;
class TargetOptions;
class Value;
}
//===----------------------------------------------------------------------===//
/// LTOModule - C++ class which implements the opaque lto_module_t type.
///
struct LTOModule {
private:
typedef llvm::StringMap<uint8_t> StringSet;
struct NameAndAttributes {
const char *name;
uint32_t attributes;
bool isFunction;
const llvm::GlobalValue *symbol;
};
llvm::OwningPtr<llvm::Module> _module;
llvm::OwningPtr<llvm::TargetMachine> _target;
std::vector<NameAndAttributes> _symbols;
// _defines and _undefines only needed to disambiguate tentative definitions
StringSet _defines;
llvm::StringMap<NameAndAttributes> _undefines;
std::vector<const char*> _asm_undefines;
llvm::MCContext _context;
// Use mangler to add GlobalPrefix to names to match linker names.
llvm::Mangler _mangler;
LTOModule(llvm::Module *m, llvm::TargetMachine *t);
public:
/// isBitcodeFile - Returns 'true' if the file or memory contents is LLVM
/// bitcode.
static bool isBitcodeFile(const void *mem, size_t length);
static bool isBitcodeFile(const char *path);
/// isBitcodeFileForTarget - Returns 'true' if the file or memory contents
/// is LLVM bitcode for the specified triple.
static bool isBitcodeFileForTarget(const void *mem,
size_t length,
const char *triplePrefix);
static bool isBitcodeFileForTarget(const char *path,
const char *triplePrefix);
/// makeLTOModule - Create an LTOModule. N.B. These methods take ownership
/// of the buffer.
static LTOModule *makeLTOModule(const char* path,
std::string &errMsg);
static LTOModule *makeLTOModule(int fd, const char *path,
size_t size, std::string &errMsg);
static LTOModule *makeLTOModule(int fd, const char *path,
size_t file_size,
size_t map_size,
off_t offset,
std::string& errMsg);
static LTOModule *makeLTOModule(const void *mem, size_t length,
std::string &errMsg);
/// getTargetTriple - Return the Module's target triple.
const char *getTargetTriple() {
return _module->getTargetTriple().c_str();
}
/// setTargetTriple - Set the Module's target triple.
void setTargetTriple(const char *triple) {
_module->setTargetTriple(triple);
}
/// getSymbolCount - Get the number of symbols
uint32_t getSymbolCount() {
return _symbols.size();
}
/// getSymbolAttributes - Get the attributes for a symbol at the specified
/// index.
lto_symbol_attributes getSymbolAttributes(uint32_t index) {
if (index < _symbols.size())
return lto_symbol_attributes(_symbols[index].attributes);
return lto_symbol_attributes(0);
}
/// getSymbolName - Get the name of the symbol at the specified index.
const char *getSymbolName(uint32_t index) {
if (index < _symbols.size())
return _symbols[index].name;
return NULL;
}
/// getLLVVMModule - Return the Module.
llvm::Module *getLLVVMModule() { return _module.get(); }
/// getAsmUndefinedRefs -
const std::vector<const char*> &getAsmUndefinedRefs() {
return _asm_undefines;
}
/// getTargetOptions - Fill the TargetOptions object with the options
/// specified on the command line.
static void getTargetOptions(llvm::TargetOptions &Options);
private:
/// parseSymbols - Parse the symbols from the module and model-level ASM and
/// add them to either the defined or undefined lists.
bool parseSymbols(std::string &errMsg);
/// addPotentialUndefinedSymbol - Add a symbol which isn't defined just yet
/// to a list to be resolved later.
void addPotentialUndefinedSymbol(const llvm::GlobalValue *dcl, bool isFunc);
/// addDefinedSymbol - Add a defined symbol to the list.
void addDefinedSymbol(const llvm::GlobalValue *def, bool isFunction);
/// addDefinedFunctionSymbol - Add a function symbol as defined to the list.
void addDefinedFunctionSymbol(const llvm::Function *f);
/// addDefinedDataSymbol - Add a data symbol as defined to the list.
void addDefinedDataSymbol(const llvm::GlobalValue *v);
/// addAsmGlobalSymbols - Add global symbols from module-level ASM to the
/// defined or undefined lists.
bool addAsmGlobalSymbols(std::string &errMsg);
/// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the
/// defined list.
void addAsmGlobalSymbol(const char *, lto_symbol_attributes scope);
/// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to
/// the undefined list.
void addAsmGlobalSymbolUndef(const char *);
/// addObjCClass - Parse i386/ppc ObjC class data structure.
void addObjCClass(const llvm::GlobalVariable *clgv);
/// addObjCCategory - Parse i386/ppc ObjC category data structure.
void addObjCCategory(const llvm::GlobalVariable *clgv);
/// addObjCClassRef - Parse i386/ppc ObjC class list data structure.
void addObjCClassRef(const llvm::GlobalVariable *clgv);
/// objcClassNameFromExpression - Get string that the data pointer points
/// to.
bool objcClassNameFromExpression(const llvm::Constant* c, std::string &name);
/// isTargetMatch - Returns 'true' if the memory buffer is for the specified
/// target triple.
static bool isTargetMatch(llvm::MemoryBuffer *memBuffer,
const char *triplePrefix);
/// makeLTOModule - Create an LTOModule (private version). N.B. This
/// method takes ownership of the buffer.
static LTOModule *makeLTOModule(llvm::MemoryBuffer *buffer,
std::string &errMsg);
/// makeBuffer - Create a MemoryBuffer from a memory range.
static llvm::MemoryBuffer *makeBuffer(const void *mem, size_t length);
};
#endif // LTO_MODULE_H