mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-29 10:32:47 +00:00
8ed9951c3a
This avoids warnings when included in a application that uses -Wstrict-prototypes. e.g: AsmPrinters.def:27:1: warning: function declaration isn't a prototype [-Wstrict-prototypes] git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@155997 91177308-0d34-0410-b5e6-96231b3b80d8
254 lines
10 KiB
C++
254 lines
10 KiB
C++
/*===-- llvm-c/Target.h - Target Lib C Iface --------------------*- C++ -*-===*/
|
|
/* */
|
|
/* The LLVM Compiler Infrastructure */
|
|
/* */
|
|
/* This file is distributed under the University of Illinois Open Source */
|
|
/* License. See LICENSE.TXT for details. */
|
|
/* */
|
|
/*===----------------------------------------------------------------------===*/
|
|
/* */
|
|
/* This header declares the C interface to libLLVMTarget.a, which */
|
|
/* implements target information. */
|
|
/* */
|
|
/* Many exotic languages can interoperate with C code but have a harder time */
|
|
/* with C++ due to name mangling. So in addition to C, this interface enables */
|
|
/* tools written in such languages. */
|
|
/* */
|
|
/*===----------------------------------------------------------------------===*/
|
|
|
|
#ifndef LLVM_C_TARGET_H
|
|
#define LLVM_C_TARGET_H
|
|
|
|
#include "llvm-c/Core.h"
|
|
#include "llvm/Config/llvm-config.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* @defgroup LLVMCTarget Target information
|
|
* @ingroup LLVMC
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
enum LLVMByteOrdering { LLVMBigEndian, LLVMLittleEndian };
|
|
|
|
typedef struct LLVMOpaqueTargetData *LLVMTargetDataRef;
|
|
typedef struct LLVMOpaqueTargetLibraryInfotData *LLVMTargetLibraryInfoRef;
|
|
typedef struct LLVMStructLayout *LLVMStructLayoutRef;
|
|
|
|
/* Declare all of the target-initialization functions that are available. */
|
|
#define LLVM_TARGET(TargetName) \
|
|
void LLVMInitialize##TargetName##TargetInfo(void);
|
|
#include "llvm/Config/Targets.def"
|
|
#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
|
|
|
|
#define LLVM_TARGET(TargetName) void LLVMInitialize##TargetName##Target(void);
|
|
#include "llvm/Config/Targets.def"
|
|
#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
|
|
|
|
#define LLVM_TARGET(TargetName) \
|
|
void LLVMInitialize##TargetName##TargetMC(void);
|
|
#include "llvm/Config/Targets.def"
|
|
#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
|
|
|
|
/* Declare all of the available assembly printer initialization functions. */
|
|
#define LLVM_ASM_PRINTER(TargetName) \
|
|
void LLVMInitialize##TargetName##AsmPrinter(void);
|
|
#include "llvm/Config/AsmPrinters.def"
|
|
#undef LLVM_ASM_PRINTER /* Explicit undef to make SWIG happier */
|
|
|
|
/* Declare all of the available assembly parser initialization functions. */
|
|
#define LLVM_ASM_PARSER(TargetName) \
|
|
void LLVMInitialize##TargetName##AsmParser(void);
|
|
#include "llvm/Config/AsmParsers.def"
|
|
#undef LLVM_ASM_PARSER /* Explicit undef to make SWIG happier */
|
|
|
|
/* Declare all of the available disassembler initialization functions. */
|
|
#define LLVM_DISASSEMBLER(TargetName) \
|
|
void LLVMInitialize##TargetName##Disassembler(void);
|
|
#include "llvm/Config/Disassemblers.def"
|
|
#undef LLVM_DISASSEMBLER /* Explicit undef to make SWIG happier */
|
|
|
|
/** LLVMInitializeAllTargetInfos - The main program should call this function if
|
|
it wants access to all available targets that LLVM is configured to
|
|
support. */
|
|
static inline void LLVMInitializeAllTargetInfos(void) {
|
|
#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetInfo();
|
|
#include "llvm/Config/Targets.def"
|
|
#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
|
|
}
|
|
|
|
/** LLVMInitializeAllTargets - The main program should call this function if it
|
|
wants to link in all available targets that LLVM is configured to
|
|
support. */
|
|
static inline void LLVMInitializeAllTargets(void) {
|
|
#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##Target();
|
|
#include "llvm/Config/Targets.def"
|
|
#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
|
|
}
|
|
|
|
/** LLVMInitializeAllTargetMCs - The main program should call this function if
|
|
it wants access to all available target MC that LLVM is configured to
|
|
support. */
|
|
static inline void LLVMInitializeAllTargetMCs(void) {
|
|
#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetMC();
|
|
#include "llvm/Config/Targets.def"
|
|
#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
|
|
}
|
|
|
|
/** LLVMInitializeAllAsmPrinters - The main program should call this function if
|
|
it wants all asm printers that LLVM is configured to support, to make them
|
|
available via the TargetRegistry. */
|
|
static inline void LLVMInitializeAllAsmPrinters(void) {
|
|
#define LLVM_ASM_PRINTER(TargetName) LLVMInitialize##TargetName##AsmPrinter();
|
|
#include "llvm/Config/AsmPrinters.def"
|
|
#undef LLVM_ASM_PRINTER /* Explicit undef to make SWIG happier */
|
|
}
|
|
|
|
/** LLVMInitializeAllAsmParsers - The main program should call this function if
|
|
it wants all asm parsers that LLVM is configured to support, to make them
|
|
available via the TargetRegistry. */
|
|
static inline void LLVMInitializeAllAsmParsers(void) {
|
|
#define LLVM_ASM_PARSER(TargetName) LLVMInitialize##TargetName##AsmParser();
|
|
#include "llvm/Config/AsmParsers.def"
|
|
#undef LLVM_ASM_PARSER /* Explicit undef to make SWIG happier */
|
|
}
|
|
|
|
/** LLVMInitializeAllDisassemblers - The main program should call this function
|
|
if it wants all disassemblers that LLVM is configured to support, to make
|
|
them available via the TargetRegistry. */
|
|
static inline void LLVMInitializeAllDisassemblers(void) {
|
|
#define LLVM_DISASSEMBLER(TargetName) \
|
|
LLVMInitialize##TargetName##Disassembler();
|
|
#include "llvm/Config/Disassemblers.def"
|
|
#undef LLVM_DISASSEMBLER /* Explicit undef to make SWIG happier */
|
|
}
|
|
|
|
/** LLVMInitializeNativeTarget - The main program should call this function to
|
|
initialize the native target corresponding to the host. This is useful
|
|
for JIT applications to ensure that the target gets linked in correctly. */
|
|
static inline LLVMBool LLVMInitializeNativeTarget(void) {
|
|
/* If we have a native target, initialize it to ensure it is linked in. */
|
|
#ifdef LLVM_NATIVE_TARGET
|
|
LLVM_NATIVE_TARGETINFO();
|
|
LLVM_NATIVE_TARGET();
|
|
LLVM_NATIVE_TARGETMC();
|
|
return 0;
|
|
#else
|
|
return 1;
|
|
#endif
|
|
}
|
|
|
|
/*===-- Target Data -------------------------------------------------------===*/
|
|
|
|
/** Creates target data from a target layout string.
|
|
See the constructor llvm::TargetData::TargetData. */
|
|
LLVMTargetDataRef LLVMCreateTargetData(const char *StringRep);
|
|
|
|
/** Adds target data information to a pass manager. This does not take ownership
|
|
of the target data.
|
|
See the method llvm::PassManagerBase::add. */
|
|
void LLVMAddTargetData(LLVMTargetDataRef, LLVMPassManagerRef);
|
|
|
|
/** Adds target library information to a pass manager. This does not take
|
|
ownership of the target library info.
|
|
See the method llvm::PassManagerBase::add. */
|
|
void LLVMAddTargetLibraryInfo(LLVMTargetLibraryInfoRef, LLVMPassManagerRef);
|
|
|
|
/** Converts target data to a target layout string. The string must be disposed
|
|
with LLVMDisposeMessage.
|
|
See the constructor llvm::TargetData::TargetData. */
|
|
char *LLVMCopyStringRepOfTargetData(LLVMTargetDataRef);
|
|
|
|
/** Returns the byte order of a target, either LLVMBigEndian or
|
|
LLVMLittleEndian.
|
|
See the method llvm::TargetData::isLittleEndian. */
|
|
enum LLVMByteOrdering LLVMByteOrder(LLVMTargetDataRef);
|
|
|
|
/** Returns the pointer size in bytes for a target.
|
|
See the method llvm::TargetData::getPointerSize. */
|
|
unsigned LLVMPointerSize(LLVMTargetDataRef);
|
|
|
|
/** Returns the integer type that is the same size as a pointer on a target.
|
|
See the method llvm::TargetData::getIntPtrType. */
|
|
LLVMTypeRef LLVMIntPtrType(LLVMTargetDataRef);
|
|
|
|
/** Computes the size of a type in bytes for a target.
|
|
See the method llvm::TargetData::getTypeSizeInBits. */
|
|
unsigned long long LLVMSizeOfTypeInBits(LLVMTargetDataRef, LLVMTypeRef);
|
|
|
|
/** Computes the storage size of a type in bytes for a target.
|
|
See the method llvm::TargetData::getTypeStoreSize. */
|
|
unsigned long long LLVMStoreSizeOfType(LLVMTargetDataRef, LLVMTypeRef);
|
|
|
|
/** Computes the ABI size of a type in bytes for a target.
|
|
See the method llvm::TargetData::getTypeAllocSize. */
|
|
unsigned long long LLVMABISizeOfType(LLVMTargetDataRef, LLVMTypeRef);
|
|
|
|
/** Computes the ABI alignment of a type in bytes for a target.
|
|
See the method llvm::TargetData::getTypeABISize. */
|
|
unsigned LLVMABIAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef);
|
|
|
|
/** Computes the call frame alignment of a type in bytes for a target.
|
|
See the method llvm::TargetData::getTypeABISize. */
|
|
unsigned LLVMCallFrameAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef);
|
|
|
|
/** Computes the preferred alignment of a type in bytes for a target.
|
|
See the method llvm::TargetData::getTypeABISize. */
|
|
unsigned LLVMPreferredAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef);
|
|
|
|
/** Computes the preferred alignment of a global variable in bytes for a target.
|
|
See the method llvm::TargetData::getPreferredAlignment. */
|
|
unsigned LLVMPreferredAlignmentOfGlobal(LLVMTargetDataRef,
|
|
LLVMValueRef GlobalVar);
|
|
|
|
/** Computes the structure element that contains the byte offset for a target.
|
|
See the method llvm::StructLayout::getElementContainingOffset. */
|
|
unsigned LLVMElementAtOffset(LLVMTargetDataRef, LLVMTypeRef StructTy,
|
|
unsigned long long Offset);
|
|
|
|
/** Computes the byte offset of the indexed struct element for a target.
|
|
See the method llvm::StructLayout::getElementContainingOffset. */
|
|
unsigned long long LLVMOffsetOfElement(LLVMTargetDataRef, LLVMTypeRef StructTy,
|
|
unsigned Element);
|
|
|
|
/** Deallocates a TargetData.
|
|
See the destructor llvm::TargetData::~TargetData. */
|
|
void LLVMDisposeTargetData(LLVMTargetDataRef);
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
|
|
namespace llvm {
|
|
class TargetData;
|
|
class TargetLibraryInfo;
|
|
|
|
inline TargetData *unwrap(LLVMTargetDataRef P) {
|
|
return reinterpret_cast<TargetData*>(P);
|
|
}
|
|
|
|
inline LLVMTargetDataRef wrap(const TargetData *P) {
|
|
return reinterpret_cast<LLVMTargetDataRef>(const_cast<TargetData*>(P));
|
|
}
|
|
|
|
inline TargetLibraryInfo *unwrap(LLVMTargetLibraryInfoRef P) {
|
|
return reinterpret_cast<TargetLibraryInfo*>(P);
|
|
}
|
|
|
|
inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfo *P) {
|
|
TargetLibraryInfo *X = const_cast<TargetLibraryInfo*>(P);
|
|
return reinterpret_cast<LLVMTargetLibraryInfoRef>(X);
|
|
}
|
|
}
|
|
|
|
#endif /* defined(__cplusplus) */
|
|
|
|
#endif
|