Target.h revision ff33d833225d392600626f8f7bdfdf5a29482e75 
1/*===-- llvm-c/Target.h - Target Lib C Iface --------------------*- C++ -*-===*\
2|*                                                                            *|
3|*                     The LLVM Compiler Infrastructure                       *|
4|*                                                                            *|
5|* This file is distributed under the University of Illinois Open Source      *|
6|* License. See LICENSE.TXT for details.                                      *|
7|*                                                                            *|
8|*===----------------------------------------------------------------------===*|
9|*                                                                            *|
10|* This header declares the C interface to libLLVMTarget.a, which             *|
11|* implements target information.                                             *|
12|*                                                                            *|
13|* Many exotic languages can interoperate with C code but have a harder time  *|
14|* with C++ due to name mangling. So in addition to C, this interface enables *|
15|* tools written in such languages.                                           *|
16|*                                                                            *|
17\*===----------------------------------------------------------------------===*/
18
19#ifndef LLVM_C_TARGET_H
20#define LLVM_C_TARGET_H
21
22#include "llvm-c/Core.h"
23#include "llvm/Config/config.h"
24
25#ifdef __cplusplus
26extern "C" {
27#endif
28
29enum LLVMByteOrdering { LLVMBigEndian, LLVMLittleEndian };
30
31typedef struct LLVMOpaqueTargetData *LLVMTargetDataRef;
32typedef struct LLVMStructLayout *LLVMStructLayoutRef;
33
34/* Declare all of the target-initialization functions that are available. */
35#define LLVM_TARGET(TargetName) void LLVMInitialize##TargetName##TargetInfo(void);
36#include "llvm/Config/Targets.def"
37#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
38
39#define LLVM_TARGET(TargetName) void LLVMInitialize##TargetName##Target(void);
40#include "llvm/Config/Targets.def"
41#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
42
43/** LLVMInitializeAllTargetInfos - The main program should call this function if
44    it wants access to all available targets that LLVM is configured to
45    support. */
46static inline void LLVMInitializeAllTargetInfos() {
47#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetInfo();
48#include "llvm/Config/Targets.def"
49#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
50}
51
52/** LLVMInitializeAllTargets - The main program should call this function if it
53    wants to link in all available targets that LLVM is configured to
54    support. */
55static inline void LLVMInitializeAllTargets() {
56#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##Target();
57#include "llvm/Config/Targets.def"
58#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
59}
60
61/** LLVMInitializeNativeTarget - The main program should call this function to
62    initialize the native target corresponding to the host.  This is useful
63    for JIT applications to ensure that the target gets linked in correctly. */
64static inline LLVMBool LLVMInitializeNativeTarget() {
65  /* If we have a native target, initialize it to ensure it is linked in. */
66#ifdef LLVM_NATIVE_ARCH
67#define DoInit2(TARG) \
68  LLVMInitialize ## TARG ## Info ();          \
69  LLVMInitialize ## TARG ()
70#define DoInit(T) DoInit2(T)
71  DoInit(LLVM_NATIVE_ARCH);
72  return 0;
73#undef DoInit
74#undef DoInit2
75#else
76  return 1;
77#endif
78}
79
80/*===-- Target Data -------------------------------------------------------===*/
81
82/** Creates target data from a target layout string.
83    See the constructor llvm::TargetData::TargetData. */
84LLVMTargetDataRef LLVMCreateTargetData(const char *StringRep);
85
86/** Adds target data information to a pass manager. This does not take ownership
87    of the target data.
88    See the method llvm::PassManagerBase::add. */
89void LLVMAddTargetData(LLVMTargetDataRef, LLVMPassManagerRef);
90
91/** Converts target data to a target layout string. The string must be disposed
92    with LLVMDisposeMessage.
93    See the constructor llvm::TargetData::TargetData. */
94char *LLVMCopyStringRepOfTargetData(LLVMTargetDataRef);
95
96/** Returns the byte order of a target, either LLVMBigEndian or
97    LLVMLittleEndian.
98    See the method llvm::TargetData::isLittleEndian. */
99enum LLVMByteOrdering LLVMByteOrder(LLVMTargetDataRef);
100
101/** Returns the pointer size in bytes for a target.
102    See the method llvm::TargetData::getPointerSize. */
103unsigned LLVMPointerSize(LLVMTargetDataRef);
104
105/** Returns the integer type that is the same size as a pointer on a target.
106    See the method llvm::TargetData::getIntPtrType. */
107LLVMTypeRef LLVMIntPtrType(LLVMTargetDataRef);
108
109/** Computes the size of a type in bytes for a target.
110    See the method llvm::TargetData::getTypeSizeInBits. */
111unsigned long long LLVMSizeOfTypeInBits(LLVMTargetDataRef, LLVMTypeRef);
112
113/** Computes the storage size of a type in bytes for a target.
114    See the method llvm::TargetData::getTypeStoreSize. */
115unsigned long long LLVMStoreSizeOfType(LLVMTargetDataRef, LLVMTypeRef);
116
117/** Computes the ABI size of a type in bytes for a target.
118    See the method llvm::TargetData::getTypeAllocSize. */
119unsigned long long LLVMABISizeOfType(LLVMTargetDataRef, LLVMTypeRef);
120
121/** Computes the ABI alignment of a type in bytes for a target.
122    See the method llvm::TargetData::getTypeABISize. */
123unsigned LLVMABIAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef);
124
125/** Computes the call frame alignment of a type in bytes for a target.
126    See the method llvm::TargetData::getTypeABISize. */
127unsigned LLVMCallFrameAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef);
128
129/** Computes the preferred alignment of a type in bytes for a target.
130    See the method llvm::TargetData::getTypeABISize. */
131unsigned LLVMPreferredAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef);
132
133/** Computes the preferred alignment of a global variable in bytes for a target.
134    See the method llvm::TargetData::getPreferredAlignment. */
135unsigned LLVMPreferredAlignmentOfGlobal(LLVMTargetDataRef,
136                                        LLVMValueRef GlobalVar);
137
138/** Computes the structure element that contains the byte offset for a target.
139    See the method llvm::StructLayout::getElementContainingOffset. */
140unsigned LLVMElementAtOffset(LLVMTargetDataRef, LLVMTypeRef StructTy,
141                             unsigned long long Offset);
142
143/** Computes the byte offset of the indexed struct element for a target.
144    See the method llvm::StructLayout::getElementContainingOffset. */
145unsigned long long LLVMOffsetOfElement(LLVMTargetDataRef, LLVMTypeRef StructTy,
146                                       unsigned Element);
147
148/** Struct layouts are speculatively cached. If a TargetDataRef is alive when
149    types are being refined and removed, this method must be called whenever a
150    struct type is removed to avoid a dangling pointer in this cache.
151    See the method llvm::TargetData::InvalidateStructLayoutInfo. */
152void LLVMInvalidateStructLayout(LLVMTargetDataRef, LLVMTypeRef StructTy);
153
154/** Deallocates a TargetData.
155    See the destructor llvm::TargetData::~TargetData. */
156void LLVMDisposeTargetData(LLVMTargetDataRef);
157
158
159#ifdef __cplusplus
160}
161
162namespace llvm {
163  class TargetData;
164
165  inline TargetData *unwrap(LLVMTargetDataRef P) {
166    return reinterpret_cast<TargetData*>(P);
167  }
168
169  inline LLVMTargetDataRef wrap(const TargetData *P) {
170    return reinterpret_cast<LLVMTargetDataRef>(const_cast<TargetData*>(P));
171  }
172}
173
174#endif /* defined(__cplusplus) */
175
176#endif
177